#define DALI_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
#include <dali/public-api/adaptor-framework/application.h>
#include <dali/public-api/adaptor-framework/device-status.h>
#include <dali/public-api/adaptor-framework/input-method.h>
-#include <dali/public-api/adaptor-framework/key.h>
#include <dali/public-api/adaptor-framework/key-grab.h>
+#include <dali/public-api/adaptor-framework/key.h>
+#include <dali/public-api/adaptor-framework/native-image-source.h>
#include <dali/public-api/adaptor-framework/timer.h>
#include <dali/public-api/adaptor-framework/tts-player.h>
-#include <dali/public-api/adaptor-framework/native-image-source.h>
#include <dali/public-api/adaptor-framework/widget-application.h>
#include <dali/public-api/adaptor-framework/widget-impl.h>
#include <dali/public-api/adaptor-framework/widget.h>
namespace Dali
{
-
/**
* AccessibilityActionHandler is an abstract interface, used by Dali to handle accessibility actions
* passed by the accessibility manager.
class AccessibilityActionHandler
{
public:
-
/**
* Change the accessibility status when Accessibility feature(screen-reader) turned on or off.
* @return whether the status is changed or not.
* @param touch The touch point (and time) of the event.
* @return whether the focus is cleared or not.
*/
- virtual bool AccessibilityActionScroll( Dali::TouchEvent& touch ) = 0;
+ virtual bool AccessibilityActionScroll(Dali::TouchEvent& touch) = 0;
/**
* Perform the accessibility action to move focus to the previous focusable actor (by one finger flick up).
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
AccessibilityAdaptor::AccessibilityAdaptor()
{
}
return Internal::Adaptor::AccessibilityAdaptor::GetImplementation(*this).HandleActionActivateEvent();
}
-bool AccessibilityAdaptor::HandleActionReadEvent(unsigned int x, unsigned int y, bool allowReadAgain)
+bool AccessibilityAdaptor::HandleActionReadEvent(unsigned int x, unsigned int y, bool allowReadAgain)
{
return Internal::Adaptor::AccessibilityAdaptor::GetImplementation(*this).HandleActionReadEvent(x, y, allowReadAgain);
}
return Internal::Adaptor::AccessibilityAdaptor::GetImplementation(*this).HandleActionStartStopEvent();
}
-AccessibilityAdaptor::AccessibilityAdaptor( Internal::Adaptor::AccessibilityAdaptor& manager )
-: BaseHandle( &manager )
+AccessibilityAdaptor::AccessibilityAdaptor(Internal::Adaptor::AccessibilityAdaptor& manager)
+: BaseHandle(&manager)
{
}
-AccessibilityAdaptor::AccessibilityAdaptor( Internal::Adaptor::AccessibilityAdaptor* manager )
-: BaseHandle( manager )
+AccessibilityAdaptor::AccessibilityAdaptor(Internal::Adaptor::AccessibilityAdaptor* manager)
+: BaseHandle(manager)
{
}
#define DALI_ACCESSIBILITY_ADAPTOR_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*
*/
-
// EXTERNAL INCLUDES
#include <dali/devel-api/events/touch-point.h>
-#include <dali/public-api/object/base-handle.h>
#include <dali/public-api/dali-adaptor-common.h>
+#include <dali/public-api/object/base-handle.h>
namespace Dali
{
-
namespace Internal DALI_INTERNAL
{
namespace Adaptor
{
class AccessibilityAdaptor;
}
-}
+} // namespace DALI_INTERNAL
class AccessibilityActionHandler;
class AccessibilityGestureHandler;
class DALI_ADAPTOR_API AccessibilityAdaptor : public BaseHandle
{
public:
-
/**
* @brief Create an uninitialized handle.
*
bool HandleActionStartStopEvent();
public: // Not intended for application developers
-
/**
* @brief Creates a handle using the Adaptor::Internal implementation.
*
* @param[in] adaptor The AccessibilityAdaptor implementation.
*/
- DALI_INTERNAL AccessibilityAdaptor( Internal::Adaptor::AccessibilityAdaptor& adaptor );
+ DALI_INTERNAL AccessibilityAdaptor(Internal::Adaptor::AccessibilityAdaptor& adaptor);
/**
* @brief This constructor is used by AccessibilityAdaptor::Get().
*
* @param[in] adaptor A pointer to the accessibility adaptor.
*/
- explicit DALI_INTERNAL AccessibilityAdaptor( Internal::Adaptor::AccessibilityAdaptor* adaptor );
+ explicit DALI_INTERNAL AccessibilityAdaptor(Internal::Adaptor::AccessibilityAdaptor* adaptor);
};
} // namespace Dali
#define DALI_INTEGRAION_ACCESSIBILITY_GESTURE_STRUCTS_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
struct AccessibilityGestureEvent
{
// Construction & Destruction
* @param[in] state The state of the gesture
*/
AccessibilityGestureEvent(AccessibilityGestureEvent::State state)
- : timeDelta( 0 ),
- numberOfTouches( 0 ),
- state( state ),
- time( 0 )
- {}
+ : timeDelta(0),
+ numberOfTouches(0),
+ state(state),
+ time(0)
+ {
+ }
};
} // namespace Dali
#define DALI_ACCESSIBILITY_GESTURE_HANDLER_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
/**
* AccessibilityGestureHandler is an interface used by Dali to handle accessibility gestures
* passed by the accessibility manager.
class AccessibilityGestureHandler
{
public:
-
/**
* Handle the accessibility pan gesture.
* @param[in] panEvent The pan event to be handled.
* @return whether the gesture is handled successfully or not.
*/
- virtual bool HandlePanGesture( const AccessibilityGestureEvent& panEvent ) = 0;
+ virtual bool HandlePanGesture(const AccessibilityGestureEvent& panEvent) = 0;
}; // class AccessibilityGestureHandler
namespace Dali
{
-
AnimatedImageLoading::AnimatedImageLoading()
{
}
-AnimatedImageLoading AnimatedImageLoading::New( const std::string& url, bool isLocalResource )
+AnimatedImageLoading AnimatedImageLoading::New(const std::string& url, bool isLocalResource)
{
const std::size_t urlSize = url.length();
Internal::Adaptor::AnimatedImageLoadingPtr internal = NULL;
- if(urlSize >= 4){ // Avoid throwing out_of_range or failing silently if exceptions are turned-off on the compare(). (http://www.cplusplus.com/reference/string/string/compare/)
- if( !url.compare( urlSize - 4, 4, ".gif" )
- || !url.compare( urlSize - 4, 4, ".GIF" ) )
+ if(urlSize >= 4)
+ { // Avoid throwing out_of_range or failing silently if exceptions are turned-off on the compare(). (http://www.cplusplus.com/reference/string/string/compare/)
+ if(!url.compare(urlSize - 4, 4, ".gif") || !url.compare(urlSize - 4, 4, ".GIF"))
{
- internal = Internal::Adaptor::GifLoading::New( url, isLocalResource );
+ internal = Internal::Adaptor::GifLoading::New(url, isLocalResource);
}
}
- if(urlSize >= 5){ // Avoid throwing out_of_range or failing silently if exceptions are turned-off on the compare(). (http://www.cplusplus.com/reference/string/string/compare/)
- if( !url.compare( urlSize - 5, 5, ".webp" )
- || !url.compare( urlSize - 5, 5, ".WEBP" ) )
+ if(urlSize >= 5)
+ { // Avoid throwing out_of_range or failing silently if exceptions are turned-off on the compare(). (http://www.cplusplus.com/reference/string/string/compare/)
+ if(!url.compare(urlSize - 5, 5, ".webp") || !url.compare(urlSize - 5, 5, ".WEBP"))
{
- internal = Internal::Adaptor::WebPLoading::New( url, isLocalResource );
+ internal = Internal::Adaptor::WebPLoading::New(url, isLocalResource);
}
}
- return AnimatedImageLoading( internal.Get() );
+ return AnimatedImageLoading(internal.Get());
}
-AnimatedImageLoading AnimatedImageLoading::DownCast( BaseHandle handle )
+AnimatedImageLoading AnimatedImageLoading::DownCast(BaseHandle handle)
{
- return AnimatedImageLoading( dynamic_cast< Internal::Adaptor::AnimatedImageLoading* >( handle.GetObjectPtr() ) );
+ return AnimatedImageLoading(dynamic_cast<Internal::Adaptor::AnimatedImageLoading*>(handle.GetObjectPtr()));
}
AnimatedImageLoading::~AnimatedImageLoading()
{
}
-bool AnimatedImageLoading::LoadNextNFrames( uint32_t frameStartIndex, int count, std::vector<Dali::PixelData>& pixelData )
+bool AnimatedImageLoading::LoadNextNFrames(uint32_t frameStartIndex, int count, std::vector<Dali::PixelData>& pixelData)
{
- return GetImplementation( *this ).LoadNextNFrames( frameStartIndex, count, pixelData );
+ return GetImplementation(*this).LoadNextNFrames(frameStartIndex, count, pixelData);
}
-Dali::Devel::PixelBuffer AnimatedImageLoading::LoadFrame( uint32_t frameIndex )
+Dali::Devel::PixelBuffer AnimatedImageLoading::LoadFrame(uint32_t frameIndex)
{
- return GetImplementation( *this ).LoadFrame( frameIndex );
+ return GetImplementation(*this).LoadFrame(frameIndex);
}
ImageDimensions AnimatedImageLoading::GetImageSize() const
{
- return GetImplementation( *this ).GetImageSize();
+ return GetImplementation(*this).GetImageSize();
}
uint32_t AnimatedImageLoading::GetImageCount() const
{
- return GetImplementation( *this ).GetImageCount();
+ return GetImplementation(*this).GetImageCount();
}
-uint32_t AnimatedImageLoading::GetFrameInterval( uint32_t frameIndex ) const
+uint32_t AnimatedImageLoading::GetFrameInterval(uint32_t frameIndex) const
{
- return GetImplementation( *this ).GetFrameInterval( frameIndex );
+ return GetImplementation(*this).GetFrameInterval(frameIndex);
}
std::string AnimatedImageLoading::GetUrl() const
{
- return GetImplementation( *this ).GetUrl();
+ return GetImplementation(*this).GetUrl();
}
-AnimatedImageLoading::AnimatedImageLoading( Internal::Adaptor::AnimatedImageLoading* internal )
-: BaseHandle( internal )
+AnimatedImageLoading::AnimatedImageLoading(Internal::Adaptor::AnimatedImageLoading* internal)
+: BaseHandle(internal)
{
}
#include <dali/public-api/object/base-handle.h>
// INTERNAL INCLUDES
-#include <dali/public-api/dali-adaptor-common.h>
#include <dali/devel-api/adaptor-framework/pixel-buffer.h>
+#include <dali/public-api/dali-adaptor-common.h>
namespace Dali
{
-
class PixelData;
typedef Dali::Uint16Pair ImageDimensions;
{
class AnimatedImageLoading;
}
-}
+} // namespace DALI_INTERNAL
/**
* Class to manage loading frames of an animated image in small chunks. Lazy initializes only when
class DALI_ADAPTOR_API AnimatedImageLoading : public BaseHandle
{
public:
-
/**
* Create a GifLoading with the given url and resourceType.
* @param[in] url The url of the animated image to load
* @param[in] isLocalResource The true or false whether this is a local resource.
* @return A newly created GifLoading.
*/
- static AnimatedImageLoading New( const std::string& url, bool isLocalResource );
+ static AnimatedImageLoading New(const std::string& url, bool isLocalResource);
/**
* @brief Constructor
* @param[in] handle to An object.
* @return handle to a Capture object or an uninitialized handle.
*/
- static AnimatedImageLoading DownCast( BaseHandle handle );
-
+ static AnimatedImageLoading DownCast(BaseHandle handle);
/**
* @brief Copy constructor.
* @param[out] pixelData The vector in which to return the frame data
* @return True if the frame data was successfully loaded
*/
- bool LoadNextNFrames( uint32_t frameStartIndex, int count, std::vector<Dali::PixelData>& pixelData );
+ bool LoadNextNFrames(uint32_t frameStartIndex, int count, std::vector<Dali::PixelData>& pixelData);
- /**
+ /**
* @brief Load a frame of the animated image.
*
* @note This function will load the entire animated image into memory if not already loaded.
* @return Dali::Devel::PixelBuffer The loaded PixelBuffer. If loading is fail, return empty handle.
*/
- Dali::Devel::PixelBuffer LoadFrame( uint32_t frameIndex );
+ Dali::Devel::PixelBuffer LoadFrame(uint32_t frameIndex);
/**
* @brief Get the size of a animated image.
*
* @return The time interval of the frame(microsecond).
*/
- uint32_t GetFrameInterval( uint32_t frameIndex ) const;
+ uint32_t GetFrameInterval(uint32_t frameIndex) const;
/**
* @brief Get the animated image file URL
*
* @param[in] internal A pointer to a newly allocated Dali resource.
*/
- explicit DALI_INTERNAL AnimatedImageLoading( Internal::Adaptor::AnimatedImageLoading* internal );
+ explicit DALI_INTERNAL AnimatedImageLoading(Internal::Adaptor::AnimatedImageLoading* internal);
/// @endcond
};
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace DevelApplication
{
-
-
-bool AddIdleWithReturnValue( Application application, CallbackBase* callback )
+bool AddIdleWithReturnValue(Application application, CallbackBase* callback)
{
- return Internal::Adaptor::GetImplementation( application ).AddIdle( callback, true );
+ return Internal::Adaptor::GetImplementation(application).AddIdle(callback, true);
}
std::string GetDataPath()
return Internal::Adaptor::Application::GetDataPath();
}
-Application DownCast( Dali::RefObject* refObject )
+Application DownCast(Dali::RefObject* refObject)
{
- return Application( dynamic_cast<Dali::Internal::Adaptor::Application*>( refObject ) );
+ return Application(dynamic_cast<Dali::Internal::Adaptor::Application*>(refObject));
}
} // namespace DevelApplication
} // namespace Dali
-extern "C"
-void ApplicationPreInitialize( int* argc, char** argv[] )
+extern "C" void ApplicationPreInitialize(int* argc, char** argv[])
{
- Dali::Internal::Adaptor::Application::PreInitialize( argc, argv );
+ Dali::Internal::Adaptor::Application::PreInitialize(argc, argv);
}
-
#define DALI_APPLICATION_DEVEL_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace DevelApplication
{
-
-
/**
* @brief Ensures that the function passed in is called from the main loop when it is idle.
* @param[in] application A handle to the Application
*
* @note Ownership of the callback is passed onto this class.
*/
-DALI_ADAPTOR_API bool AddIdleWithReturnValue( Application application, CallbackBase* callback );
+DALI_ADAPTOR_API bool AddIdleWithReturnValue(Application application, CallbackBase* callback);
/**
* @brief Gets the absolute path to the application's data directory which is used to store private data of the application.
* @param[in] refObject to an Application
* @return handle to an Application object or an uninitialized base handle
*/
-DALI_ADAPTOR_API Application DownCast( Dali::RefObject* refObject );
+DALI_ADAPTOR_API Application DownCast(Dali::RefObject* refObject);
} // namespace DevelApplication
* @note Declared in C style for calling from app-launcher.
*
*/
-extern "C"
-DALI_ADAPTOR_API void ApplicationPreInitialize( int* argc, char** argv[] );
+extern "C" DALI_ADAPTOR_API void ApplicationPreInitialize(int* argc, char** argv[]);
#endif // DALI_APPLICATION_DEVEL_H
#ifndef DALI_DEVEL_ATSPI_ACCESSIBILITY_H
#define DALI_DEVEL_ATSPI_ACCESSIBILITY_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
* Callback can be one of the following signals:
* ReadingCancelled, ReadingStopped, ReadingSkipped
*/
-DALI_ADAPTOR_API void Say( const std::string &text, bool discardable, std::function<void(std::string)> callback );
+DALI_ADAPTOR_API void Say(const std::string& text, bool discardable, std::function<void(std::string)> callback);
/**
* @brief Force accessibility client to pause.
* @return The status of ATSPI : 0(ATSPI OFF, ScreenReader OFF), 1(ATSPI ON, ScreenReader OFF),
* 2 (ATSPI OFF, ScreenReader ON), 3(ATSPI ON, ScreenReader ON)
*/
-DALI_ADAPTOR_API int SetForcefully( bool turnOn );
+DALI_ADAPTOR_API int SetForcefully(bool turnOn);
/**
* @brief Get ATSPI status.
#include <dali/internal/legacy/common/tizen-platform-abstraction.h>
#include <dali/internal/legacy/tizen/image-encoder.h>
-
namespace Dali
{
-
// Pieces needed to save compressed images (temporary location while plumbing):
namespace
{
-
/**
* Simple function to tell intended image file format from filename
*/
-FileFormat GetFormatFromFileName( const std::string& filename )
+FileFormat GetFormatFromFileName(const std::string& filename)
{
- if (filename.length() < 5)
+ if(filename.length() < 5)
{
DALI_LOG_WARNING("Invalid (short) filename.\n");
}
const std::size_t filenameSize = filename.length();
- if(filenameSize >= 4){ // Avoid throwing out_of_range or failing silently if exceptions are turned-off on the compare(). (http://www.cplusplus.com/reference/string/string/compare/)
- if( !filename.compare( filenameSize - 4, 4, ".jpg" )
- || !filename.compare( filenameSize - 4, 4, ".JPG" ) )
+ if(filenameSize >= 4)
+ { // Avoid throwing out_of_range or failing silently if exceptions are turned-off on the compare(). (http://www.cplusplus.com/reference/string/string/compare/)
+ if(!filename.compare(filenameSize - 4, 4, ".jpg") || !filename.compare(filenameSize - 4, 4, ".JPG"))
{
format = JPG_FORMAT;
}
- else if( !filename.compare( filenameSize - 4, 4, ".png" )
- || !filename.compare( filenameSize - 4, 4, ".PNG" ) )
+ else if(!filename.compare(filenameSize - 4, 4, ".png") || !filename.compare(filenameSize - 4, 4, ".PNG"))
{
format = PNG_FORMAT;
}
- else if( !filename.compare( filenameSize - 4, 4, ".bmp" )
- || !filename.compare( filenameSize - 4, 4, ".BMP" ) )
+ else if(!filename.compare(filenameSize - 4, 4, ".bmp") || !filename.compare(filenameSize - 4, 4, ".BMP"))
{
format = BMP_FORMAT;
}
- else if( !filename.compare( filenameSize - 4, 4, ".gif" )
- || !filename.compare( filenameSize - 4, 4, ".GIF" ) )
+ else if(!filename.compare(filenameSize - 4, 4, ".gif") || !filename.compare(filenameSize - 4, 4, ".GIF"))
{
format = GIF_FORMAT;
}
- else if( !filename.compare( filenameSize - 4, 4, ".ico" )
- || !filename.compare( filenameSize - 4, 4, ".ICO" ) )
+ else if(!filename.compare(filenameSize - 4, 4, ".ico") || !filename.compare(filenameSize - 4, 4, ".ICO"))
{
format = ICO_FORMAT;
}
- else if(filenameSize >= 5){
- if( !filename.compare( filenameSize - 5, 5, ".jpeg" )
- || !filename.compare( filenameSize - 5, 5, ".JPEG" ) )
+ else if(filenameSize >= 5)
+ {
+ if(!filename.compare(filenameSize - 5, 5, ".jpeg") || !filename.compare(filenameSize - 5, 5, ".JPEG"))
{
format = JPG_FORMAT;
}
return format;
}
-bool EncodeToFormat( const unsigned char* pixelBuffer,
- Vector< unsigned char >& encodedPixels,
- FileFormat formatEncoding,
- std::size_t width,
- std::size_t height,
- Pixel::Format pixelFormat,
- const uint32_t quality )
+bool EncodeToFormat(const unsigned char* pixelBuffer,
+ Vector<unsigned char>& encodedPixels,
+ FileFormat formatEncoding,
+ std::size_t width,
+ std::size_t height,
+ Pixel::Format pixelFormat,
+ const uint32_t quality)
{
- switch( formatEncoding )
+ switch(formatEncoding)
{
case JPG_FORMAT:
{
- return TizenPlatform::EncodeToJpeg( pixelBuffer, encodedPixels, width, height, pixelFormat, quality );
+ return TizenPlatform::EncodeToJpeg(pixelBuffer, encodedPixels, width, height, pixelFormat, quality);
break;
}
case PNG_FORMAT:
{
- return TizenPlatform::EncodeToPng( pixelBuffer, encodedPixels, width, height, pixelFormat );
+ return TizenPlatform::EncodeToPng(pixelBuffer, encodedPixels, width, height, pixelFormat);
break;
}
default:
}
} // anonymous namespace
-
bool EncodeToFile(const unsigned char* const pixelBuffer,
- const std::string& filename,
- const Pixel::Format pixelFormat,
- const std::size_t width,
- const std::size_t height )
+ const std::string& filename,
+ const Pixel::Format pixelFormat,
+ const std::size_t width,
+ const std::size_t height)
{
- return EncodeToFile( pixelBuffer, filename, pixelFormat, width, height, DEFAULT_JPG_QUALITY );
+ return EncodeToFile(pixelBuffer, filename, pixelFormat, width, height, DEFAULT_JPG_QUALITY);
}
bool EncodeToFile(const unsigned char* const pixelBuffer,
- const std::string& filename,
- const Pixel::Format pixelFormat,
- const std::size_t width,
- const std::size_t height,
- const uint32_t quality )
+ const std::string& filename,
+ const Pixel::Format pixelFormat,
+ const std::size_t width,
+ const std::size_t height,
+ const uint32_t quality)
{
DALI_ASSERT_DEBUG(pixelBuffer != 0 && filename.size() > 4 && width > 0 && height > 0);
- Vector< unsigned char > pixbufEncoded;
- const FileFormat format = GetFormatFromFileName( filename );
- const bool encodeResult = EncodeToFormat( pixelBuffer, pixbufEncoded, format, width, height, pixelFormat, quality );
+ Vector<unsigned char> pixbufEncoded;
+ const FileFormat format = GetFormatFromFileName(filename);
+ const bool encodeResult = EncodeToFormat(pixelBuffer, pixbufEncoded, format, width, height, pixelFormat, quality);
if(!encodeResult)
{
DALI_LOG_ERROR("Encoding pixels failed\n");
return false;
}
- return TizenPlatform::SaveFile( filename, pixbufEncoded.Begin(), pixbufEncoded.Count() );
+ return TizenPlatform::SaveFile(filename, pixbufEncoded.Begin(), pixbufEncoded.Count());
}
} // namespace Dali
*/
// EXTERNAL INCLUDES
-#include <string>
#include <dali/public-api/images/pixel.h>
+#include <string>
// INTERNAL INCLUDES
#include <dali/public-api/dali-adaptor-common.h>
namespace Dali
{
-
static constexpr uint32_t DEFAULT_JPG_QUALITY = 100;
/**
* @return true if the file was saved
*/
DALI_ADAPTOR_API bool EncodeToFile(const unsigned char* const pixelBuffer,
- const std::string& filename,
- const Pixel::Format pixelFormat,
- const std::size_t width,
- const std::size_t height);
+ const std::string& filename,
+ const Pixel::Format pixelFormat,
+ const std::size_t width,
+ const std::size_t height);
/**
* Store the given pixel data to a file.
* @return true if the file was saved
*/
DALI_ADAPTOR_API bool EncodeToFile(const unsigned char* const pixelBuffer,
- const std::string& filename,
- const Pixel::Format pixelFormat,
- const std::size_t width,
- const std::size_t height,
- const uint32_t quality);
+ const std::string& filename,
+ const Pixel::Format pixelFormat,
+ const std::size_t width,
+ const std::size_t height,
+ const uint32_t quality);
} // namespace Dali
-
#endif // DALI_ADAPTOR_BITMAP_SAVER_H
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
ClipboardEventNotifier::ClipboardEventNotifier()
{
}
return Internal::Adaptor::ClipboardEventNotifier::GetImplementation(*this).GetContent();
}
-void ClipboardEventNotifier::SetContent( const std::string& content )
+void ClipboardEventNotifier::SetContent(const std::string& content)
{
Internal::Adaptor::ClipboardEventNotifier::GetImplementation(*this).SetContent(content);
}
return Internal::Adaptor::ClipboardEventNotifier::GetImplementation(*this).ContentSelectedSignal();
}
-ClipboardEventNotifier::ClipboardEventNotifier( Internal::Adaptor::ClipboardEventNotifier* notifier )
-: BaseHandle( notifier )
+ClipboardEventNotifier::ClipboardEventNotifier(Internal::Adaptor::ClipboardEventNotifier* notifier)
+: BaseHandle(notifier)
{
}
#define DALI_CLIPBOARD_EVENT_NOTIFIER_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Internal DALI_INTERNAL
{
namespace Adaptor
{
class ClipboardEventNotifier;
}
-}
+} // namespace DALI_INTERNAL
/**
* @brief The ClipboardEventNotifier provides signals when clipboard events are received from the device.
class DALI_ADAPTOR_API ClipboardEventNotifier : public BaseHandle
{
public:
-
// Typedefs
/**
* @brief Clipboard event
*/
- typedef Signal< void ( ClipboardEventNotifier& ) > ClipboardEventSignalType;
+ typedef Signal<void(ClipboardEventNotifier&)> ClipboardEventSignalType;
/**
* @brief Create an uninitialized handle.
* @brief Sets the selected content.
* @param[in] content A string that represents the content that has been selected.
*/
- void SetContent( const std::string& content );
+ void SetContent(const std::string& content);
/**
* @brief Clears the stored content.
*/
void EmitContentSelectedSignal();
-public: // Signals
-
+public: // Signals
/**
* @brief This is emitted when content is selected from the clipboard.
*
ClipboardEventSignalType& ContentSelectedSignal();
public: // Not intended for application developers
-
/**
* @brief This constructor is used by ClipboardEventNotifier::Get().
*
* @param[in] notifier A pointer to the drag and drop notifier.
*/
- explicit DALI_INTERNAL ClipboardEventNotifier( Internal::Adaptor::ClipboardEventNotifier* notifier );
+ explicit DALI_INTERNAL ClipboardEventNotifier(Internal::Adaptor::ClipboardEventNotifier* notifier);
};
} // namespace Dali
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
Clipboard::Clipboard()
{
}
Clipboard::~Clipboard()
{
}
-Clipboard::Clipboard(Internal::Adaptor::Clipboard *impl)
- : BaseHandle(impl)
+Clipboard::Clipboard(Internal::Adaptor::Clipboard* impl)
+: BaseHandle(impl)
{
}
return Internal::Adaptor::Clipboard::Get();
}
-bool Clipboard::SetItem( const std::string &itemData)
+bool Clipboard::SetItem(const std::string& itemData)
{
- return GetImplementation(*this).SetItem( itemData );
+ return GetImplementation(*this).SetItem(itemData);
}
void Clipboard::RequestItem()
-#ifndef DALI_CLIPBOARD_H
-#define DALI_CLIPBOARD_H
+#ifndef DALI_CLIPBOARD_H
+#define DALI_CLIPBOARD_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*
*/
-
// EXTERNAL INCLUDES
#include <dali/public-api/math/rect.h>
#include <dali/public-api/object/base-handle.h>
namespace Dali
{
-
namespace Internal DALI_INTERNAL
{
-
namespace Adaptor
{
class Clipboard;
}
-}
+} // namespace DALI_INTERNAL
/**
* @brief Interface to the device's clipboard.
*
* @param[in] clipboard A pointer to the clipboard.
*/
- explicit DALI_INTERNAL Clipboard( Internal::Adaptor::Clipboard* clipboard );
+ explicit DALI_INTERNAL Clipboard(Internal::Adaptor::Clipboard* clipboard);
/**
* @brief Retrieve a handle to the ClipboardEventNotifier instance.
* @param[in] itemData string to send to clip board
* @return bool true if the internal clip board sending was successful.
*/
- bool SetItem( const std::string& itemData );
+ bool SetItem(const std::string& itemData);
/**
* @brief Request clipboard service to retrieve an item
* @return bool true if the clipboard is visible.
*/
bool IsVisible() const;
-
};
} // namespace Dali
#define DALI_COLOR_CONTROLLER_PLUGIN_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
/**
* @brief ColorControllerPlugin is an abstract interface, used by dali-adaptor to access Color Controller plugin.
* A concrete implementation must be created for each platform and provided as dynamic library.
class ColorControllerPlugin
{
public:
-
/**
* @brief Constructor.
*/
- ColorControllerPlugin(){}
+ ColorControllerPlugin()
+ {
+ }
/**
* @brief Destructor.
*/
- virtual ~ColorControllerPlugin(){}
+ virtual ~ColorControllerPlugin()
+ {
+ }
/**
* @brief Retrieve the RGBA value by given the color code.
* @param[out] colorValue The RGBA color
* @return true if the color code exists, otherwise false
*/
- virtual bool RetrieveColor( const std::string& colorCode, Vector4& colorValue ) const = 0;
+ virtual bool RetrieveColor(const std::string& colorCode, Vector4& colorValue) const = 0;
/**
* @brief Retrieve the RGBA value by given the color code.
* @param[out] textShadowColor The text shadow color.
* @return true if the color code exists, otherwise false
*/
- virtual bool RetrieveColor( const std::string& colorCode , Vector4& textColor, Vector4& textOutlineColor, Vector4& textShadowColor ) const = 0;
+ virtual bool RetrieveColor(const std::string& colorCode, Vector4& textColor, Vector4& textOutlineColor, Vector4& textShadowColor) const = 0;
};
-} // namespace Dali;
+} // namespace Dali
#endif // DALI_COLOR_CONTROLLER_PLUGIN_H
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
ColorController::ColorController()
{
}
{
}
-bool ColorController::RetrieveColor( const std::string& colorCode, Vector4& colorValue )
+bool ColorController::RetrieveColor(const std::string& colorCode, Vector4& colorValue)
{
- return GetImplementation(*this).RetrieveColor( colorCode, colorValue );
+ return GetImplementation(*this).RetrieveColor(colorCode, colorValue);
}
-bool ColorController::RetrieveColor( const std::string& colorCode , Vector4& textColor, Vector4& textOutlineColor, Vector4& textShadowColor)
+bool ColorController::RetrieveColor(const std::string& colorCode, Vector4& textColor, Vector4& textOutlineColor, Vector4& textShadowColor)
{
- return GetImplementation(*this).RetrieveColor( colorCode, textColor, textOutlineColor, textShadowColor );
+ return GetImplementation(*this).RetrieveColor(colorCode, textColor, textOutlineColor, textShadowColor);
}
ColorController::ColorController(Internal::Adaptor::ColorController* internal)
{
}
-}
+} // namespace Dali
#define DALI_COLOR_CONTROLLER_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
// EXTERNAL INCLUDES
-#include <string>
-#include <dali/public-api/object/base-handle.h>
#include <dali/public-api/math/vector4.h>
+#include <dali/public-api/object/base-handle.h>
+#include <string>
// INTERNAL INCLUDES
#include <dali/public-api/dali-adaptor-common.h>
namespace Dali
{
-
namespace Internal DALI_INTERNAL
{
namespace Adaptor
class ColorController;
}
-}
+} // namespace DALI_INTERNAL
/**
* Color controller currently caches the changeable color table which updates with the theme change
class DALI_ADAPTOR_API ColorController : public BaseHandle
{
public:
-
/**
* @brief Create an uninitialized ColorController handle.
*/
* The copy will point to the same implementation as the original.
* @param[in] colorController The Color Controller to copy from.
*/
- ColorController( const ColorController& colorController);
+ ColorController(const ColorController& colorController);
/**
* @brief This assignment operator is required for (smart) pointer semantics.
* @param[out] colorValue The RGBA color
* @return true if the color code exists, otherwise false
*/
- bool RetrieveColor( const std::string& colorCode, Vector4& colorValue );
+ bool RetrieveColor(const std::string& colorCode, Vector4& colorValue);
/**
* @brief Retrieve the RGBA values by given the color code.
* @param[out] textShadowColor The text shadow color.
* @return true if the color code exists, otherwise false
*/
- bool RetrieveColor( const std::string& colorCode , Vector4& textColor, Vector4& textOutlineColor, Vector4& textShadowColor);
-
+ bool RetrieveColor(const std::string& colorCode, Vector4& textColor, Vector4& textOutlineColor, Vector4& textShadowColor);
public: // Not intended for application developers
/**
explicit DALI_INTERNAL ColorController(Internal::Adaptor::ColorController* colorController);
};
-
} //namespace Dali
#endif // DALI_COLOR_CONTROLLER_H
{\r
namespace Internal DALI_INTERNAL\r
{\r
-\r
namespace Adaptor\r
{\r
class ComponentApplication;\r
}\r
\r
-}\r
+} // namespace DALI_INTERNAL\r
\r
/**\r
* @brief An ComponentApplication class object should be created by every component-based application\r
class DALI_ADAPTOR_API ComponentApplication : public Application\r
{\r
public:\r
- typedef Signal< Any () > CreateSignalType;\r
+ typedef Signal<Any()> CreateSignalType;\r
\r
public:\r
/**
* @brief This is the constructor for component applications without an argument list.\r
* @return A handle to the ComponentApplication\r
*/\r
- static ComponentApplication New( );\r
-
+ static ComponentApplication New();\r
+\r
/**
* @brief This is the constructor for component applications.\r
*\r
* @param[in,out] argv A pointer to the argument list\r
* @return A handle to the ComponentApplication\r
*/\r
- static ComponentApplication New( int* argc, char **argv[] );\r
-
+ static ComponentApplication New(int* argc, char** argv[]);\r
+\r
/**
* @brief This is the constructor for component applications with a stylesheet\r
*\r
* @param[in] stylesheet The path to user defined theme file
* @return A handle to the ComponentApplication\r
*/\r
- static ComponentApplication New( int* argc, char **argv[], const std::string& stylesheet );\r
+ static ComponentApplication New(int* argc, char** argv[], const std::string& stylesheet);\r
\r
/**\r
* @brief The default constructor.\r
*\r
* @param[in] componentApplication Handle to an object\r
*/\r
- ComponentApplication( const ComponentApplication& componentApplication ) = default;\r
+ ComponentApplication(const ComponentApplication& componentApplication) = default;\r
\r
/**\r
* @brief Assignment operator.\r
* @param[in] componentApplication Handle to an object\r
* @return A reference to this\r
*/\r
- ComponentApplication& operator=( const ComponentApplication& componentApplication ) = default;\r
+ ComponentApplication& operator=(const ComponentApplication& componentApplication) = default;\r
\r
- /**\r
+ /**\r
* @brief Destructor\r
*/\r
~ComponentApplication() = default;\r
\r
- /**\r
+ /**\r
* @brief The user should connect to this signal to determine when they should initialize\r
* their application.\r
* The callback function is called before the main loop of the application starts.\r
} // namespace Dali\r
\r
#endif // DALI_COMPONENT_APPLICATION_H\r
-\r
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace EnvironmentVariable
{
-
-const char * GetEnvironmentVariable( const char * variable )
+const char* GetEnvironmentVariable(const char* variable)
{
- return std::getenv( variable );
+ return std::getenv(variable);
}
-bool SetEnvironmentVariable( const char * variable, const char * value )
+bool SetEnvironmentVariable(const char* variable, const char* value)
{
- return setenv( variable, value, 1 ) == 0;
+ return setenv(variable, value, 1) == 0;
}
} // namespace EnvironmentVariable
#define DALI_ENVIRONMENT_VARIABLE_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace EnvironmentVariable
{
-
/**
* @brief Search the environment list for the specified variable name and return a pointer to the C string that is associated with the matched environment list member.
*
* @param[in] variable Null-terminated character string identifying the name of the environmental variable to look for.
* @return A C-string containing the value of the specified environment variable.
*/
-DALI_ADAPTOR_API const char * GetEnvironmentVariable( const char * variable );
+DALI_ADAPTOR_API const char* GetEnvironmentVariable(const char* variable);
/**
* @brief Create or overwrite (when it does not exist) an environment variable.
* @param[in] value Null-terminated character string to set as a value.
* @return True on success, false on error.
*/
-DALI_ADAPTOR_API bool SetEnvironmentVariable( const char * variable, const char * value );
+DALI_ADAPTOR_API bool SetEnvironmentVariable(const char* variable, const char* value);
} // namespace EnvironmentVariable
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace EventFeeder
{
-
-void FeedTouchPoint( TouchPoint& point, int timeStamp )
+void FeedTouchPoint(TouchPoint& point, int timeStamp)
{
- if ( Adaptor::IsAvailable() )
+ if(Adaptor::IsAvailable())
{
- Internal::Adaptor::Adaptor::GetImplementation( Adaptor::Get() ).FeedTouchPoint( point, timeStamp );
+ Internal::Adaptor::Adaptor::GetImplementation(Adaptor::Get()).FeedTouchPoint(point, timeStamp);
}
}
-void FeedWheelEvent( WheelEvent& wheelEvent )
+void FeedWheelEvent(WheelEvent& wheelEvent)
{
- if ( Adaptor::IsAvailable() )
+ if(Adaptor::IsAvailable())
{
- Internal::Adaptor::Adaptor::GetImplementation( Adaptor::Get() ).FeedWheelEvent( wheelEvent );
+ Internal::Adaptor::Adaptor::GetImplementation(Adaptor::Get()).FeedWheelEvent(wheelEvent);
}
}
-void FeedKeyEvent( KeyEvent& keyEvent )
+void FeedKeyEvent(KeyEvent& keyEvent)
{
- if ( Adaptor::IsAvailable() )
+ if(Adaptor::IsAvailable())
{
- Internal::Adaptor::Adaptor::GetImplementation( Adaptor::Get() ).FeedKeyEvent( keyEvent );
+ Internal::Adaptor::Adaptor::GetImplementation(Adaptor::Get()).FeedKeyEvent(keyEvent);
}
}
namespace Dali
{
-
class WheelEvent;
class KeyEvent;
struct TouchPoint;
namespace EventFeeder
{
-
/**
* Feed a touch point to the adaptor.
*
*
* @note For testing/automation purposes only.
*/
-DALI_ADAPTOR_API void FeedTouchPoint( TouchPoint& point, int timeStamp );
+DALI_ADAPTOR_API void FeedTouchPoint(TouchPoint& point, int timeStamp);
/**
* Feed a wheel event to the adaptor.
*
* @note For testing/automation purposes only.
*/
-DALI_ADAPTOR_API void FeedWheelEvent( WheelEvent& wheelEvent );
+DALI_ADAPTOR_API void FeedWheelEvent(WheelEvent& wheelEvent);
/**
* Feed a key event to the adaptor.
*
* @note For testing/automation purposes only.
*/
-DALI_ADAPTOR_API void FeedKeyEvent( KeyEvent& keyEvent );
+DALI_ADAPTOR_API void FeedKeyEvent(KeyEvent& keyEvent);
} // namespace EventFeeder
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
struct EventThreadCallback::Impl
{
TriggerEventInterface* eventTrigger;
};
-EventThreadCallback::EventThreadCallback( CallbackBase* callback )
-: mImpl( new Impl() )
+EventThreadCallback::EventThreadCallback(CallbackBase* callback)
+: mImpl(new Impl())
{
- mImpl->eventTrigger = TriggerEventFactory::CreateTriggerEvent( callback, TriggerEventInterface::KEEP_ALIVE_AFTER_TRIGGER );
+ mImpl->eventTrigger = TriggerEventFactory::CreateTriggerEvent(callback, TriggerEventInterface::KEEP_ALIVE_AFTER_TRIGGER);
}
EventThreadCallback::~EventThreadCallback()
{
- TriggerEventFactory::DestroyTriggerEvent( mImpl->eventTrigger );
+ TriggerEventFactory::DestroyTriggerEvent(mImpl->eventTrigger);
delete mImpl;
}
void EventThreadCallback::Trigger()
{
- if( mImpl->eventTrigger )
+ if(mImpl->eventTrigger)
{
mImpl->eventTrigger->Trigger();
}
}
-}
+} // namespace Dali
#define DALI_EVENT_THREAD_CALLBACK_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
/**
* @brief The EventThreadCallback class provides a mechanism for the worker thread to trigger the execution of a given callback in main event thread .
*
class DALI_ADAPTOR_API EventThreadCallback
{
public:
-
/**
* @brief Constructor. Create an object that will call the given callback in main event thread.
*
* @param[in] callback The callback to call.
*/
- EventThreadCallback( CallbackBase* callback );
+ EventThreadCallback(CallbackBase* callback);
/**
* @brief Destructor.
void Trigger();
private:
-
// undefined copy constructor.
- EventThreadCallback( const EventThreadCallback& );
+ EventThreadCallback(const EventThreadCallback&);
// undefined assignment operator
- EventThreadCallback& operator=( const EventThreadCallback& );
+ EventThreadCallback& operator=(const EventThreadCallback&);
private:
-
struct Impl;
Impl* mImpl;
-
};
-}
+} // namespace Dali
#endif /* DALI_EVENT_THREAD_CALLBACK_H */
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
FeedbackPlayer::FeedbackPlayer()
{
}
GetImplementation(*this).Stop();
}
-int FeedbackPlayer::PlaySound( const std::string& fileName )
+int FeedbackPlayer::PlaySound(const std::string& fileName)
{
return GetImplementation(*this).PlaySound(fileName);
}
-void FeedbackPlayer::StopSound( int handle )
+void FeedbackPlayer::StopSound(int handle)
{
GetImplementation(*this).StopSound(handle);
}
-void FeedbackPlayer::PlayFeedbackPattern( int type, int pattern )
+void FeedbackPlayer::PlayFeedbackPattern(int type, int pattern)
{
GetImplementation(*this).PlayFeedbackPattern(type, pattern);
}
return GetImplementation(*this).LoadFile(filename, data);
}
-FeedbackPlayer::FeedbackPlayer( Internal::Adaptor::FeedbackPlayer* player )
-: BaseHandle( player )
+FeedbackPlayer::FeedbackPlayer(Internal::Adaptor::FeedbackPlayer* player)
+: BaseHandle(player)
{
}
#define DALI_FEEDBACK_PLAYER_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Internal DALI_INTERNAL
{
namespace Adaptor
{
class FeedbackPlayer;
}
-}
+} // namespace DALI_INTERNAL
/**
* @brief Plays feedback effects.
class DALI_ADAPTOR_API FeedbackPlayer : public BaseHandle
{
public:
-
/**
* @brief Create an uninitialized handle.
*
* @param[in] fileName Path to the sound file to play.
* @return A handle which can be used to stop the sound playback.
*/
- int PlaySound( const std::string& fileName );
+ int PlaySound(const std::string& fileName);
/**
* Stops a currently playing sound.
* @param[in] handle A handle to the currently playing sound.
*/
- void StopSound( int handle );
+ void StopSound(int handle);
/**
* Plays a feedback pattern.
* @param[in] type The type of feedback.
* @param[in] pattern The ID of the pattern to play.
*/
- void PlayFeedbackPattern( int type, int pattern );
+ void PlayFeedbackPattern(int type, int pattern);
/*
* Loads a file into data
bool LoadFile(const std::string& filename, std::string& data);
public: // Not intended for application developers
-
/**
* @brief This constructor is used by FeedbackPlayer::Get().
* @param[in] feedbackPlayer A pointer to the feedback player.
*/
- explicit DALI_INTERNAL FeedbackPlayer( Internal::Adaptor::FeedbackPlayer* feedbackPlayer );
+ explicit DALI_INTERNAL FeedbackPlayer(Internal::Adaptor::FeedbackPlayer* feedbackPlayer);
};
} // namespace Dali
#define DALI_FEEDBACK_PLUGIN_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
/**
* FeedbackPlugin is an abstract interface, used by Dali-adaptor to access haptic and audio feedback.
* A concrete implementation must be created for each platform and provided as a dynamic library which
class FeedbackPlugin
{
public:
-
- typedef void (*SoundStopCallBack)( void* ptr );
+ typedef void (*SoundStopCallBack)(void* ptr);
/**
* Destructor.
* Plays vibration in predefined patterns.
* @param[in] filePath Path to the file containing the effect.
*/
- virtual void PlayHaptic( const std::string& filePath ) = 0;
+ virtual void PlayHaptic(const std::string& filePath) = 0;
/**
* Plays a monotone vibration.
* @param[in] duration The duration of the vibration.
*/
- virtual void PlayHapticMonotone( unsigned int duration ) = 0;
+ virtual void PlayHapticMonotone(unsigned int duration) = 0;
/**
* Stops the currently playing vibration effects.
* @param[in] fileName Path to the sound file to play.
* @return A handle which can be used to stop the sound playback.
*/
- virtual int PlaySound( const std::string& fileName ) = 0;
+ virtual int PlaySound(const std::string& fileName) = 0;
/**
* Stops a currently playing sound.
* @param[in] handle A handle to the currently playing sound.
*/
- virtual void StopSound( int handle ) = 0;
+ virtual void StopSound(int handle) = 0;
/**
* Plays a feedback pattern.
* @param[in] type The type of feedback.
* @param[in] pattern The ID of the pattern to play.
*/
- virtual void PlayFeedbackPattern( int type, int pattern ) = 0;
+ virtual void PlayFeedbackPattern(int type, int pattern) = 0;
// Types for plugin factories
* @param [in] pluginName name of the plugin to load.
* @return Pointer to the newly created plugin object
*/
- typedef FeedbackPlugin* CreateFeedbackPlugin( void );
+ typedef FeedbackPlugin* CreateFeedbackPlugin(void);
}; // class FeedbackPlugin
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
#include <dali/devel-api/adaptor-framework/file-loader.h>
// EXTERNAL INCLUDES
-#include <iostream>
#include <fstream>
+#include <iostream>
// INTERNAL INCLUDES
#include <dali/internal/adaptor-framework/common/file-loader-impl.h>
namespace Dali
{
-
namespace
{
-
// limit maximum image down load size to 50 MB
-const size_t MAXIMUM_DOWNLOAD_IMAGE_SIZE = 50 * 1024 * 1024 ;
+const size_t MAXIMUM_DOWNLOAD_IMAGE_SIZE = 50 * 1024 * 1024;
-}
+} // namespace
namespace FileLoader
{
-
-int ReadFile(const std::string& filename, Dali::Vector<char> & memblock, FileLoader::FileType fileType)
+int ReadFile(const std::string& filename, Dali::Vector<char>& memblock, FileLoader::FileType fileType)
{
- return Dali::Internal::Adaptor::ReadFile( filename, memblock, fileType );
+ return Dali::Internal::Adaptor::ReadFile(filename, memblock, fileType);
}
int ReadFile(const std::string& filename, std::streampos& fileSize, Dali::Vector<char>& memblock, FileLoader::FileType fileType)
{
- return Dali::Internal::Adaptor::ReadFile( filename, fileSize, memblock, fileType );;
+ return Dali::Internal::Adaptor::ReadFile(filename, fileSize, memblock, fileType);
+ ;
}
std::streampos GetFileSize(const std::string& filename)
return Dali::Internal::Adaptor::GetFileSize(filename);
}
-bool DownloadFileSynchronously(const std::string& filename, Dali::Vector<uint8_t> &dataBuffer)
+bool DownloadFileSynchronously(const std::string& filename, Dali::Vector<uint8_t>& dataBuffer)
{
size_t dataSize;
- return TizenPlatform::Network::DownloadRemoteFileIntoMemory( filename, dataBuffer, dataSize, MAXIMUM_DOWNLOAD_IMAGE_SIZE );
+ return TizenPlatform::Network::DownloadRemoteFileIntoMemory(filename, dataBuffer, dataSize, MAXIMUM_DOWNLOAD_IMAGE_SIZE);
}
-} //FileLoader
+} // namespace FileLoader
-} //Dali
+} // namespace Dali
#define DALI_FILE_LOADER_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
// EXTERNAL INCLUDES
-#include <string>
#include <dali/public-api/object/base-handle.h>
+#include <string>
// INTERNAL INCLUDES
#include <dali/public-api/dali-adaptor-common.h>
namespace Dali
{
-
namespace FileLoader
{
/**
* @brief File type formats
* The default format is binary
*/
-enum FileType ///< FileType format
+enum FileType ///< FileType format
{
- BINARY, ///< File will be loaded as a binary
- TEXT ///< File will be loaded as text
+ BINARY, ///< File will be loaded as a binary
+ TEXT ///< File will be loaded as text
};
/**
*
*
*/
-DALI_ADAPTOR_API int ReadFile(const std::string& filename, Dali::Vector<char> & memblock, FileLoader::FileType fileType = BINARY);
+DALI_ADAPTOR_API int ReadFile(const std::string& filename, Dali::Vector<char>& memblock, FileLoader::FileType fileType = BINARY);
/**
* @brief Load the file. It will load it either as a binary or as a text
* @return error code. 0 - Error, 1 - Ok
*
*/
-DALI_ADAPTOR_API int ReadFile(const std::string& filename, std::streampos& fileSize, Dali::Vector<char> & memblock, FileLoader::FileType fileType = BINARY);
+DALI_ADAPTOR_API int ReadFile(const std::string& filename, std::streampos& fileSize, Dali::Vector<char>& memblock, FileLoader::FileType fileType = BINARY);
/**
* @brief Get the file size of a file
*/
DALI_ADAPTOR_API std::streampos GetFileSize(const std::string& filename);
-
/**
* @brief Download a requested file into a memory buffer.
*
* @param[out] dataBuffer A memory buffer object to be written with downloaded file data.
* @return error code. false - Error, true - Ok
*/
-DALI_ADAPTOR_API bool DownloadFileSynchronously(const std::string& filename, Dali::Vector<uint8_t> &dataBuffer);
+DALI_ADAPTOR_API bool DownloadFileSynchronously(const std::string& filename, Dali::Vector<uint8_t>& dataBuffer);
-};
+}; // namespace FileLoader
-} // Dali
+} // namespace Dali
#endif // DALI_FILE_LOADER_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
FileStream::FileStream(const std::string& filename, uint8_t mode)
{
- mImpl.reset( new Impl( filename, mode ) );
+ mImpl.reset(new Impl(filename, mode));
}
FileStream::FileStream(uint8_t* buffer, size_t dataSize, uint8_t mode)
{
- mImpl.reset( new Impl( buffer, dataSize, mode ) );
+ mImpl.reset(new Impl(buffer, dataSize, mode));
}
FileStream::FileStream(Dali::Vector<uint8_t>& buffer, size_t dataSize, uint8_t mode)
{
- mImpl.reset( new Impl( buffer, dataSize, mode ) );
+ mImpl.reset(new Impl(buffer, dataSize, mode));
}
FileStream::FileStream(FileStream&&) = default;
return mImpl->GetFile();
}
-} // Dali
+} // namespace Dali
*/
// EXTERNAL INCLUDES
-#include <stdio.h>
#include <stdint.h>
+#include <stdio.h>
#include <iostream>
-#include <string>
#include <memory>
+#include <string>
// INTERNAL INCLUDES
#include <dali/public-api/common/dali-vector.h>
namespace Dali
{
-
class DALI_ADAPTOR_API FileStream
{
public:
-
/**
* @brief File type formats
* The default format is binary
*/
- enum FileMode ///< FileType format
+ enum FileMode ///< FileType format
{
- BINARY = 1 << 0, ///< File stream will be opened as a binary
- TEXT = 1 << 1, ///< File stream will be opened as text
- READ = 1 << 2, ///< File stream will be opened for reading
- WRITE = 1 << 3, ///< File stream will be opened for writing
- APPEND = 1 << 4, ///< File stream will be opened for appending
+ BINARY = 1 << 0, ///< File stream will be opened as a binary
+ TEXT = 1 << 1, ///< File stream will be opened as text
+ READ = 1 << 2, ///< File stream will be opened for reading
+ WRITE = 1 << 3, ///< File stream will be opened for writing
+ APPEND = 1 << 4, ///< File stream will be opened for appending
};
/**
FILE* GetFile();
private:
-
class Impl;
std::unique_ptr<Impl> mImpl;
};
-} // Dali
+} // namespace Dali
#endif // DALI_FILE_STREAM_H
#define DALI_TIZEN_PLATFORM_IMAGE_LOADER_INPUT_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
// EXTERNAL INCLUDES
-#include <cstdio>
-#include <dali/public-api/images/image-operations.h>
#include <dali/devel-api/adaptor-framework/pixel-buffer.h>
#include <dali/integration-api/bitmap.h>
+#include <dali/public-api/images/image-operations.h>
+#include <cstdio>
// INTERNAL INCLUDES
{
namespace ImageLoader
{
-
/**
* @brief A simple immutable struct to bundle together parameters for scaling an image.
*/
class ScalingParameters
{
public:
- ScalingParameters( ImageDimensions dimensions = ImageDimensions(), FittingMode::Type fittingMode = FittingMode::DEFAULT, SamplingMode::Type samplingMode = SamplingMode::DEFAULT ) :
- dimensions(dimensions), scalingMode(fittingMode), samplingMode(samplingMode) {}
- const ImageDimensions dimensions;
- const FittingMode::Type scalingMode;
+ ScalingParameters(ImageDimensions dimensions = ImageDimensions(), FittingMode::Type fittingMode = FittingMode::DEFAULT, SamplingMode::Type samplingMode = SamplingMode::DEFAULT)
+ : dimensions(dimensions),
+ scalingMode(fittingMode),
+ samplingMode(samplingMode)
+ {
+ }
+ const ImageDimensions dimensions;
+ const FittingMode::Type scalingMode;
const SamplingMode::Type samplingMode;
};
- /**
+/**
* @brief Bundle-up the data pushed into an image loader.
*/
struct Input
{
- Input( FILE* file, ScalingParameters scalingParameters = ScalingParameters(), bool reorientationRequested = true ) :
- file(file), scalingParameters(scalingParameters), reorientationRequested(reorientationRequested) {}
- FILE* file;
+ Input(FILE* file, ScalingParameters scalingParameters = ScalingParameters(), bool reorientationRequested = true)
+ : file(file),
+ scalingParameters(scalingParameters),
+ reorientationRequested(reorientationRequested)
+ {
+ }
+ FILE* file;
ScalingParameters scalingParameters;
- bool reorientationRequested;
+ bool reorientationRequested;
};
-
-using LoadBitmapFunction = bool( * )( const Dali::ImageLoader::Input& input, Dali::Devel::PixelBuffer& pixelData );
-using LoadBitmapHeaderFunction = bool( * )( const Dali::ImageLoader::Input& input, unsigned int& width, unsigned int& height );
+using LoadBitmapFunction = bool (*)(const Dali::ImageLoader::Input& input, Dali::Devel::PixelBuffer& pixelData);
+using LoadBitmapHeaderFunction = bool (*)(const Dali::ImageLoader::Input& input, unsigned int& width, unsigned int& height);
/**
* Stores the magic bytes, and the loader and header functions used for each image loader.
*/
struct BitmapLoader
{
- unsigned char magicByte1; ///< The first byte in the file should be this
- unsigned char magicByte2; ///< The second byte in the file should be this
- LoadBitmapFunction loader; ///< The function which decodes the file
- LoadBitmapHeaderFunction header; ///< The function which decodes the header of the file
- Dali::Integration::Bitmap::Profile profile; ///< The kind of bitmap to be created
- /// (addressable packed pixels or an opaque compressed blob).
+ unsigned char magicByte1; ///< The first byte in the file should be this
+ unsigned char magicByte2; ///< The second byte in the file should be this
+ LoadBitmapFunction loader; ///< The function which decodes the file
+ LoadBitmapHeaderFunction header; ///< The function which decodes the header of the file
+ Dali::Integration::Bitmap::Profile profile; ///< The kind of bitmap to be created
+ /// (addressable packed pixels or an opaque compressed blob).
};
-} // ImageLoader
-} // Dali
+} // namespace ImageLoader
+} // namespace Dali
#endif // DALI_TIZEN_PLATFORM_IMAGE_LOADER_INPUT_H
#define DALI_IMAGE_LOADING_PLUGIN_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
/**
* @brief
*/
class ImageLoaderPlugin
{
public:
-
/**
* @brief Constructor.
*/
- ImageLoaderPlugin(){}
+ ImageLoaderPlugin()
+ {
+ }
/**
* @brief Destructor.
*/
- virtual ~ImageLoaderPlugin(){}
+ virtual ~ImageLoaderPlugin()
+ {
+ }
/**
* @brief Get the image decorder
* @param[in] filename The path to the resource.
* @return BitmapLoader
*/
- virtual const ImageLoader::BitmapLoader* BitmapLoaderLookup( const std::string& filename ) const = 0;
+ virtual const ImageLoader::BitmapLoader* BitmapLoaderLookup(const std::string& filename) const = 0;
/**
* @brief Function pointer called in adaptor to create a image loading plugin instance.
* @return Pointer to the newly created plugin object
*/
- typedef ImageLoaderPlugin* CreateImageLoaderPlugin( void );
+ typedef ImageLoaderPlugin* CreateImageLoaderPlugin(void);
/**
* @brief Function pointer called in adaptor to destory a image loading plugin instance.
*/
- typedef void DestroyImageLoaderPlugin( ImageLoaderPlugin* plugin );
-
+ typedef void DestroyImageLoaderPlugin(ImageLoaderPlugin* plugin);
};
-} // namespace Dali;
+} // namespace Dali
#endif
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
#include <dali/devel-api/adaptor-framework/image-loading.h>
// INTERNAL INCLUDES
-#include <dali/public-api/object/property-map.h>
-#include <dali/internal/imaging/common/image-loader.h>
+#include <dali/devel-api/adaptor-framework/pixel-buffer.h>
#include <dali/internal/imaging/common/file-download.h>
+#include <dali/internal/imaging/common/image-loader.h>
#include <dali/internal/system/common/file-reader.h>
-#include <dali/devel-api/adaptor-framework/pixel-buffer.h>
+#include <dali/public-api/object/property-map.h>
namespace Dali
{
-
namespace
{
-
// limit maximum image down load size to 50 MB
-const size_t MAXIMUM_DOWNLOAD_IMAGE_SIZE = 50 * 1024 * 1024 ;
+const size_t MAXIMUM_DOWNLOAD_IMAGE_SIZE = 50 * 1024 * 1024;
-}
+} // namespace
-Devel::PixelBuffer LoadImageFromFile( const std::string& url, ImageDimensions size, FittingMode::Type fittingMode, SamplingMode::Type samplingMode, bool orientationCorrection )
+Devel::PixelBuffer LoadImageFromFile(const std::string& url, ImageDimensions size, FittingMode::Type fittingMode, SamplingMode::Type samplingMode, bool orientationCorrection)
{
- Integration::BitmapResourceType resourceType( size, fittingMode, samplingMode, orientationCorrection );
+ Integration::BitmapResourceType resourceType(size, fittingMode, samplingMode, orientationCorrection);
- Internal::Platform::FileReader fileReader( url );
- FILE * const fp = fileReader.GetFile();
- if( fp != NULL )
+ Internal::Platform::FileReader fileReader(url);
+ FILE* const fp = fileReader.GetFile();
+ if(fp != NULL)
{
Dali::Devel::PixelBuffer bitmap;
- bool success = TizenPlatform::ImageLoader::ConvertStreamToBitmap( resourceType, url, fp, bitmap );
- if( success && bitmap )
+ bool success = TizenPlatform::ImageLoader::ConvertStreamToBitmap(resourceType, url, fp, bitmap);
+ if(success && bitmap)
{
return bitmap;
}
return Dali::Devel::PixelBuffer();
}
-ImageDimensions GetClosestImageSize( const std::string& filename,
- ImageDimensions size,
- FittingMode::Type fittingMode,
- SamplingMode::Type samplingMode,
- bool orientationCorrection )
+ImageDimensions GetClosestImageSize(const std::string& filename,
+ ImageDimensions size,
+ FittingMode::Type fittingMode,
+ SamplingMode::Type samplingMode,
+ bool orientationCorrection)
{
- ImageDimensions dimension = TizenPlatform::ImageLoader::GetClosestImageSize( filename, size, fittingMode, samplingMode, orientationCorrection );
+ ImageDimensions dimension = TizenPlatform::ImageLoader::GetClosestImageSize(filename, size, fittingMode, samplingMode, orientationCorrection);
- dimension.SetWidth( std::min( dimension.GetWidth(), static_cast< uint16_t >( GetMaxTextureSize() ) ) );
- dimension.SetHeight( std::min( dimension.GetHeight(), static_cast< uint16_t >( GetMaxTextureSize() ) ) );
+ dimension.SetWidth(std::min(dimension.GetWidth(), static_cast<uint16_t>(GetMaxTextureSize())));
+ dimension.SetHeight(std::min(dimension.GetHeight(), static_cast<uint16_t>(GetMaxTextureSize())));
return dimension;
}
-ImageDimensions GetOriginalImageSize( const std::string& filename )
+ImageDimensions GetOriginalImageSize(const std::string& filename)
{
- return TizenPlatform::ImageLoader::GetClosestImageSize( filename, ImageDimensions(0, 0), FittingMode::DEFAULT, SamplingMode::BOX_THEN_LINEAR, true );
+ return TizenPlatform::ImageLoader::GetClosestImageSize(filename, ImageDimensions(0, 0), FittingMode::DEFAULT, SamplingMode::BOX_THEN_LINEAR, true);
}
-Devel::PixelBuffer DownloadImageSynchronously( const std::string& url, ImageDimensions size, FittingMode::Type fittingMode, SamplingMode::Type samplingMode, bool orientationCorrection )
+Devel::PixelBuffer DownloadImageSynchronously(const std::string& url, ImageDimensions size, FittingMode::Type fittingMode, SamplingMode::Type samplingMode, bool orientationCorrection)
{
- Integration::BitmapResourceType resourceType( size, fittingMode, samplingMode, orientationCorrection );
+ Integration::BitmapResourceType resourceType(size, fittingMode, samplingMode, orientationCorrection);
- bool succeeded;
+ bool succeeded;
Dali::Vector<uint8_t> dataBuffer;
- size_t dataSize;
+ size_t dataSize;
- succeeded = TizenPlatform::Network::DownloadRemoteFileIntoMemory( url, dataBuffer, dataSize,
- MAXIMUM_DOWNLOAD_IMAGE_SIZE );
- if( succeeded )
+ succeeded = TizenPlatform::Network::DownloadRemoteFileIntoMemory(url, dataBuffer, dataSize, MAXIMUM_DOWNLOAD_IMAGE_SIZE);
+ if(succeeded)
{
size_t blobSize = dataBuffer.Size();
- DALI_ASSERT_DEBUG( blobSize > 0U );
+ DALI_ASSERT_DEBUG(blobSize > 0U);
- if( blobSize > 0U )
+ if(blobSize > 0U)
{
// Open a file handle on the memory buffer:
- Dali::Internal::Platform::FileReader fileReader( dataBuffer, blobSize );
- FILE * const fp = fileReader.GetFile();
- if ( NULL != fp )
+ Dali::Internal::Platform::FileReader fileReader(dataBuffer, blobSize);
+ FILE* const fp = fileReader.GetFile();
+ if(NULL != fp)
{
Dali::Devel::PixelBuffer bitmap;
- bool result = TizenPlatform::ImageLoader::ConvertStreamToBitmap(
+ bool result = TizenPlatform::ImageLoader::ConvertStreamToBitmap(
resourceType,
url,
fp,
- bitmap );
+ bitmap);
- if ( result && bitmap )
+ if(result && bitmap)
{
return bitmap;
}
else
{
- DALI_LOG_WARNING( "Unable to decode bitmap supplied as in-memory blob.\n" );
+ DALI_LOG_WARNING("Unable to decode bitmap supplied as in-memory blob.\n");
}
}
}
#define DALI_IMAGE_LOADING_H
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
// EXTERNAL INCLUDES
-#include <string>
-#include <dali/public-api/images/image-operations.h>
#include <dali/devel-api/adaptor-framework/pixel-buffer.h>
+#include <dali/public-api/images/image-operations.h>
+#include <string>
// INTERNAL INCLUDES
#include <dali/public-api/dali-adaptor-common.h>
-
namespace Dali
{
-
/**
* @brief Load an image synchronously from local file.
*
*/
DALI_ADAPTOR_API Devel::PixelBuffer LoadImageFromFile(
const std::string& url,
- ImageDimensions size = ImageDimensions( 0, 0 ),
- FittingMode::Type fittingMode = FittingMode::DEFAULT,
- SamplingMode::Type samplingMode = SamplingMode::BOX_THEN_LINEAR,
- bool orientationCorrection = true );
+ ImageDimensions size = ImageDimensions(0, 0),
+ FittingMode::Type fittingMode = FittingMode::DEFAULT,
+ SamplingMode::Type samplingMode = SamplingMode::BOX_THEN_LINEAR,
+ bool orientationCorrection = true);
/**
* @brief Determine the size of an image that LoadImageFromFile will provide when
*/
DALI_ADAPTOR_API ImageDimensions GetClosestImageSize(
const std::string& filename,
- ImageDimensions size = ImageDimensions(0, 0),
- FittingMode::Type fittingMode = FittingMode::DEFAULT,
- SamplingMode::Type samplingMode = SamplingMode::BOX_THEN_LINEAR ,
- bool orientationCorrection = true );
+ ImageDimensions size = ImageDimensions(0, 0),
+ FittingMode::Type fittingMode = FittingMode::DEFAULT,
+ SamplingMode::Type samplingMode = SamplingMode::BOX_THEN_LINEAR,
+ bool orientationCorrection = true);
/**
* @brief Get the size of an original image
*/
DALI_ADAPTOR_API Devel::PixelBuffer DownloadImageSynchronously(
const std::string& url,
- ImageDimensions size = ImageDimensions( 0, 0 ),
- FittingMode::Type fittingMode = FittingMode::DEFAULT,
- SamplingMode::Type samplingMode = SamplingMode::BOX_THEN_LINEAR,
- bool orientationCorrection = true );
+ ImageDimensions size = ImageDimensions(0, 0),
+ FittingMode::Type fittingMode = FittingMode::DEFAULT,
+ SamplingMode::Type samplingMode = SamplingMode::BOX_THEN_LINEAR,
+ bool orientationCorrection = true);
/**
* @brief get the maximum texture size.
*/
DALI_ADAPTOR_API unsigned int GetMaxTextureSize();
-} // Dali
+} // namespace Dali
#endif // DALI_IMAGE_LOADING_H
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
InputMethodContext::InputMethodContext() = default;
InputMethodContext::~InputMethodContext() = default;
InputMethodContext InputMethodContext::New()
{
- return InputMethodContext::New( Actor() );
+ return InputMethodContext::New(Actor());
}
-InputMethodContext InputMethodContext::New( Actor actor )
+InputMethodContext InputMethodContext::New(Actor actor)
{
- Internal::Adaptor::InputMethodContextPtr inputMethodContext = Internal::Adaptor::InputMethodContext::New( actor );
+ Internal::Adaptor::InputMethodContextPtr inputMethodContext = Internal::Adaptor::InputMethodContext::New(actor);
- if( inputMethodContext )
+ if(inputMethodContext)
{
inputMethodContext->Initialize();
}
- return InputMethodContext( inputMethodContext.Get() );
+ return InputMethodContext(inputMethodContext.Get());
}
-InputMethodContext::InputMethodContext( const InputMethodContext& inputMethodContext )
-: BaseHandle( inputMethodContext )
+InputMethodContext::InputMethodContext(const InputMethodContext& inputMethodContext)
+: BaseHandle(inputMethodContext)
{
}
-InputMethodContext& InputMethodContext::operator=( const InputMethodContext& inputMethodContext )
+InputMethodContext& InputMethodContext::operator=(const InputMethodContext& inputMethodContext)
{
- if( *this != inputMethodContext )
- {
- BaseHandle::operator=( inputMethodContext );
- }
- return *this;
+ if(*this != inputMethodContext)
+ {
+ BaseHandle::operator=(inputMethodContext);
+ }
+ return *this;
}
-InputMethodContext InputMethodContext::DownCast( BaseHandle handle )
+InputMethodContext InputMethodContext::DownCast(BaseHandle handle)
{
- return InputMethodContext( dynamic_cast< Internal::Adaptor::InputMethodContext* >( handle.GetObjectPtr() ) );
+ return InputMethodContext(dynamic_cast<Internal::Adaptor::InputMethodContext*>(handle.GetObjectPtr()));
}
void InputMethodContext::Finalize()
return Internal::Adaptor::InputMethodContext::GetImplementation(*this).RestoreAfterFocusLost();
}
-void InputMethodContext::SetRestoreAfterFocusLost( bool toggle )
+void InputMethodContext::SetRestoreAfterFocusLost(bool toggle)
{
- Internal::Adaptor::InputMethodContext::GetImplementation(*this).SetRestoreAfterFocusLost( toggle );
+ Internal::Adaptor::InputMethodContext::GetImplementation(*this).SetRestoreAfterFocusLost(toggle);
}
void InputMethodContext::Reset()
Internal::Adaptor::InputMethodContext::GetImplementation(*this).NotifyCursorPosition();
}
-void InputMethodContext::SetCursorPosition( unsigned int SetCursorPosition )
+void InputMethodContext::SetCursorPosition(unsigned int SetCursorPosition)
{
- Internal::Adaptor::InputMethodContext::GetImplementation(*this).SetCursorPosition( SetCursorPosition );
+ Internal::Adaptor::InputMethodContext::GetImplementation(*this).SetCursorPosition(SetCursorPosition);
}
unsigned int InputMethodContext::GetCursorPosition() const
return Internal::Adaptor::InputMethodContext::GetImplementation(*this).GetCursorPosition();
}
-void InputMethodContext::SetSurroundingText( const std::string& text )
+void InputMethodContext::SetSurroundingText(const std::string& text)
{
- Internal::Adaptor::InputMethodContext::GetImplementation(*this).SetSurroundingText( text );
+ Internal::Adaptor::InputMethodContext::GetImplementation(*this).SetSurroundingText(text);
}
const std::string& InputMethodContext::GetSurroundingText() const
return Internal::Adaptor::InputMethodContext::GetImplementation(*this).GetSurroundingText();
}
-void InputMethodContext::NotifyTextInputMultiLine( bool multiLine )
+void InputMethodContext::NotifyTextInputMultiLine(bool multiLine)
{
- Internal::Adaptor::InputMethodContext::GetImplementation(*this).NotifyTextInputMultiLine( multiLine );
+ Internal::Adaptor::InputMethodContext::GetImplementation(*this).NotifyTextInputMultiLine(multiLine);
}
InputMethodContext::TextDirection InputMethodContext::GetTextDirection()
return Internal::Adaptor::InputMethodContext::GetImplementation(*this).GetInputMethodArea();
}
-void InputMethodContext::ApplyOptions( const InputMethodOptions& options )
+void InputMethodContext::ApplyOptions(const InputMethodOptions& options)
{
- Internal::Adaptor::InputMethodContext::GetImplementation(*this).ApplyOptions( options );
+ Internal::Adaptor::InputMethodContext::GetImplementation(*this).ApplyOptions(options);
}
-void InputMethodContext::SetInputPanelData( const std::string& data )
+void InputMethodContext::SetInputPanelData(const std::string& data)
{
- Internal::Adaptor::InputMethodContext::GetImplementation(*this).SetInputPanelData( data );
+ Internal::Adaptor::InputMethodContext::GetImplementation(*this).SetInputPanelData(data);
}
-void InputMethodContext::GetInputPanelData( std::string& data )
+void InputMethodContext::GetInputPanelData(std::string& data)
{
- Internal::Adaptor::InputMethodContext::GetImplementation(*this).GetInputPanelData( data );
+ Internal::Adaptor::InputMethodContext::GetImplementation(*this).GetInputPanelData(data);
}
Dali::InputMethodContext::State InputMethodContext::GetInputPanelState()
return Internal::Adaptor::InputMethodContext::GetImplementation(*this).GetInputPanelState();
}
-void InputMethodContext::SetReturnKeyState( bool visible )
+void InputMethodContext::SetReturnKeyState(bool visible)
{
- Internal::Adaptor::InputMethodContext::GetImplementation(*this).SetReturnKeyState( visible );
+ Internal::Adaptor::InputMethodContext::GetImplementation(*this).SetReturnKeyState(visible);
}
-void InputMethodContext::AutoEnableInputPanel( bool enabled )
+void InputMethodContext::AutoEnableInputPanel(bool enabled)
{
- Internal::Adaptor::InputMethodContext::GetImplementation(*this).AutoEnableInputPanel( enabled );
+ Internal::Adaptor::InputMethodContext::GetImplementation(*this).AutoEnableInputPanel(enabled);
}
void InputMethodContext::ShowInputPanel()
return Internal::Adaptor::InputMethodContext::GetImplementation(*this).GetInputPanelLocale();
}
-void InputMethodContext::SetContentMIMETypes( const std::string& mimeTypes )
+void InputMethodContext::SetContentMIMETypes(const std::string& mimeTypes)
{
- Internal::Adaptor::InputMethodContext::GetImplementation(*this).SetContentMIMETypes( mimeTypes );
+ Internal::Adaptor::InputMethodContext::GetImplementation(*this).SetContentMIMETypes(mimeTypes);
}
-bool InputMethodContext::FilterEventKey( const Dali::KeyEvent& keyEvent )
+bool InputMethodContext::FilterEventKey(const Dali::KeyEvent& keyEvent)
{
- return Internal::Adaptor::InputMethodContext::GetImplementation(*this).FilterEventKey( keyEvent );
+ return Internal::Adaptor::InputMethodContext::GetImplementation(*this).FilterEventKey(keyEvent);
}
-void InputMethodContext::AllowTextPrediction( bool prediction )
+void InputMethodContext::AllowTextPrediction(bool prediction)
{
- Internal::Adaptor::InputMethodContext::GetImplementation(*this).AllowTextPrediction( prediction );
+ Internal::Adaptor::InputMethodContext::GetImplementation(*this).AllowTextPrediction(prediction);
}
bool InputMethodContext::IsTextPredictionAllowed() const
return Internal::Adaptor::InputMethodContext::GetImplementation(*this).IsTextPredictionAllowed();
}
-void InputMethodContext::SetInputPanelLanguage( Dali::InputMethodContext::InputPanelLanguage language )
+void InputMethodContext::SetInputPanelLanguage(Dali::InputMethodContext::InputPanelLanguage language)
{
- Internal::Adaptor::InputMethodContext::GetImplementation(*this).SetInputPanelLanguage( language );
+ Internal::Adaptor::InputMethodContext::GetImplementation(*this).SetInputPanelLanguage(language);
}
Dali::InputMethodContext::InputPanelLanguage InputMethodContext::GetInputPanelLanguage() const
return Internal::Adaptor::InputMethodContext::GetImplementation(*this).GetInputPanelLanguage();
}
-void InputMethodContext::SetInputPanelPosition( unsigned int x, unsigned int y )
+void InputMethodContext::SetInputPanelPosition(unsigned int x, unsigned int y)
{
- Internal::Adaptor::InputMethodContext::GetImplementation(*this).SetInputPanelPosition( x, y );
+ Internal::Adaptor::InputMethodContext::GetImplementation(*this).SetInputPanelPosition(x, y);
}
-void InputMethodContext::GetPreeditStyle( PreEditAttributeDataContainer& attrs ) const
+void InputMethodContext::GetPreeditStyle(PreEditAttributeDataContainer& attrs) const
{
- Internal::Adaptor::InputMethodContext::GetImplementation(*this).GetPreeditStyle( attrs );
+ Internal::Adaptor::InputMethodContext::GetImplementation(*this).GetPreeditStyle(attrs);
}
// Signals
return Internal::Adaptor::InputMethodContext::GetImplementation(*this).ContentReceivedSignal();
}
-InputMethodContext::InputMethodContext(Internal::Adaptor::InputMethodContext *impl)
- : BaseHandle(impl)
+InputMethodContext::InputMethodContext(Internal::Adaptor::InputMethodContext* impl)
+: BaseHandle(impl)
{
}
} // namespace Dali
#define DALI_INPUT_METHOD_CONTEXT_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
// EXTERNAL INCLUDES
-#include <dali/public-api/events/key-event.h>
#include <dali/public-api/common/dali-vector.h>
+#include <dali/public-api/events/key-event.h>
// EXTERNAL INCLUDES
+#include <dali/devel-api/adaptor-framework/input-method-options.h>
#include <dali/public-api/object/base-handle.h>
#include <dali/public-api/signals/dali-signal.h>
-#include <dali/devel-api/adaptor-framework/input-method-options.h>
namespace Dali
{
-
namespace Internal DALI_INTERNAL
{
namespace Adaptor
{
class InputMethodContext;
}
-}
+} // namespace DALI_INTERNAL
class Actor;
class DALI_ADAPTOR_API InputMethodContext : public BaseHandle
{
public:
-
/**
* @brief The direction of text.
*/
*/
enum EventType
{
- VOID, ///< No event
- PRE_EDIT, ///< Pre-Edit changed
- COMMIT, ///< Commit recieved
- DELETE_SURROUNDING, ///< Event to delete a range of characters from the string
- GET_SURROUNDING, ///< Event to query string and cursor position
- PRIVATE_COMMAND ///< Private command sent from the input panel
+ VOID, ///< No event
+ PRE_EDIT, ///< Pre-Edit changed
+ COMMIT, ///< Commit recieved
+ DELETE_SURROUNDING, ///< Event to delete a range of characters from the string
+ GET_SURROUNDING, ///< Event to query string and cursor position
+ PRIVATE_COMMAND ///< Private command sent from the input panel
};
/**
*/
enum State
{
- DEFAULT = 0, ///< Unknown state
- SHOW, ///< Input panel is shown
- HIDE, ///< Input panel is hidden
- WILL_SHOW ///< Input panel in process of being shown
+ DEFAULT = 0, ///< Unknown state
+ SHOW, ///< Input panel is shown
+ HIDE, ///< Input panel is hidden
+ WILL_SHOW ///< Input panel in process of being shown
};
/**
*/
enum KeyboardType
{
- SOFTWARE_KEYBOARD, ///< Software keyboard (Virtual keyboard) is default
- HARDWARE_KEYBOARD ///< Hardware keyboard
+ SOFTWARE_KEYBOARD, ///< Software keyboard (Virtual keyboard) is default
+ HARDWARE_KEYBOARD ///< Hardware keyboard
};
/**
*/
enum class InputPanelLanguage
{
- AUTOMATIC, ///< IME Language automatically set depending on the system display
- ALPHABET ///< Latin alphabet at all times
+ AUTOMATIC, ///< IME Language automatically set depending on the system display
+ ALPHABET ///< Latin alphabet at all times
};
/**
struct PreeditAttributeData
{
PreeditAttributeData()
- : preeditType( PreeditStyle::NONE ),
- startIndex( 0 ),
- endIndex( 0 )
+ : preeditType(PreeditStyle::NONE),
+ startIndex(0),
+ endIndex(0)
{
}
- PreeditStyle preeditType; /// The preedit style type
- unsigned int startIndex; /// The start index of preedit
- unsigned int endIndex; /// The end index of preedit
+ PreeditStyle preeditType; /// The preedit style type
+ unsigned int startIndex; /// The start index of preedit
+ unsigned int endIndex; /// The end index of preedit
};
/**
*/
EventData()
: predictiveString(),
- eventName( VOID ),
- cursorOffset( 0 ),
- numberOfChars ( 0 )
- {
- };
+ eventName(VOID),
+ cursorOffset(0),
+ numberOfChars(0){};
/**
* @brief Constructor
* @param[in] aCursorOffset Start position from the current cursor position to start deleting characters.
* @param[in] aNumberOfChars The number of characters to delete from the cursorOffset.
*/
- EventData( EventType aEventName, const std::string& aPredictiveString, int aCursorOffset, int aNumberOfChars )
- : predictiveString( aPredictiveString ),
- eventName( aEventName ),
- cursorOffset( aCursorOffset ),
- numberOfChars( aNumberOfChars )
+ EventData(EventType aEventName, const std::string& aPredictiveString, int aCursorOffset, int aNumberOfChars)
+ : predictiveString(aPredictiveString),
+ eventName(aEventName),
+ cursorOffset(aCursorOffset),
+ numberOfChars(aNumberOfChars)
{
}
// Data
std::string predictiveString; ///< The pre-edit or commit string.
- EventType eventName; ///< The name of the event from the InputMethodContext.
- int cursorOffset; ///< Start position from the current cursor position to start deleting characters.
- int numberOfChars; ///< number of characters to delete from the cursorOffset.
+ EventType eventName; ///< The name of the event from the InputMethodContext.
+ int cursorOffset; ///< Start position from the current cursor position to start deleting characters.
+ int numberOfChars; ///< number of characters to delete from the cursorOffset.
};
/**
*/
CallbackData()
: currentText(),
- cursorPosition( 0 ),
- update( false ),
- preeditResetRequired( false )
+ cursorPosition(0),
+ update(false),
+ preeditResetRequired(false)
{
}
* @param[in] aCurrentText current text string
* @param[in] aPreeditResetRequired flag if preedit reset is required.
*/
- CallbackData( bool aUpdate, int aCursorPosition, const std::string& aCurrentText, bool aPreeditResetRequired )
- : currentText( aCurrentText ),
- cursorPosition( aCursorPosition ),
- update( aUpdate ),
- preeditResetRequired( aPreeditResetRequired )
+ CallbackData(bool aUpdate, int aCursorPosition, const std::string& aCurrentText, bool aPreeditResetRequired)
+ : currentText(aCurrentText),
+ cursorPosition(aCursorPosition),
+ update(aUpdate),
+ preeditResetRequired(aPreeditResetRequired)
{
}
- std::string currentText; ///< current text string
- int cursorPosition; ///< new position of cursor
- bool update :1; ///< if cursor position needs to be updated
- bool preeditResetRequired :1; ///< flag if preedit reset is required.
+ std::string currentText; ///< current text string
+ int cursorPosition; ///< new position of cursor
+ bool update : 1; ///< if cursor position needs to be updated
+ bool preeditResetRequired : 1; ///< flag if preedit reset is required.
};
- typedef Signal< void (InputMethodContext&) > ActivatedSignalType; ///< Keyboard actived signal
- typedef Signal< CallbackData ( InputMethodContext&, const EventData& ) > KeyboardEventSignalType; ///< keyboard events
- typedef Signal< void () > VoidSignalType;
- typedef Signal< void ( bool ) > StatusSignalType;
- typedef Signal< void ( KeyboardType ) > KeyboardTypeSignalType; ///< keyboard type
- typedef Signal< void ( int ) > KeyboardResizedSignalType; ///< Keyboard resized signal
- typedef Signal< void ( int ) > LanguageChangedSignalType; ///< Language changed signal
- typedef Signal< void ( const std::string&, const std::string&, const std::string& ) > ContentReceivedSignalType; ///< Content received signal
+ typedef Signal<void(InputMethodContext&)> ActivatedSignalType; ///< Keyboard actived signal
+ typedef Signal<CallbackData(InputMethodContext&, const EventData&)> KeyboardEventSignalType; ///< keyboard events
+ typedef Signal<void()> VoidSignalType;
+ typedef Signal<void(bool)> StatusSignalType;
+ typedef Signal<void(KeyboardType)> KeyboardTypeSignalType; ///< keyboard type
+ typedef Signal<void(int)> KeyboardResizedSignalType; ///< Keyboard resized signal
+ typedef Signal<void(int)> LanguageChangedSignalType; ///< Language changed signal
+ typedef Signal<void(const std::string&, const std::string&, const std::string&)> ContentReceivedSignalType; ///< Content received signal
- using PreEditAttributeDataContainer = Vector< Dali::InputMethodContext::PreeditAttributeData >;
+ using PreEditAttributeDataContainer = Vector<Dali::InputMethodContext::PreeditAttributeData>;
public:
-
/**
* @brief Retrieve a handle to the instance of InputMethodContext.
* @return A handle to the InputMethodContext.
*
* @param[in] actor The actor that uses the new InputMethodContext instance.
*/
- static InputMethodContext New( Actor actor );
+ static InputMethodContext New(Actor actor);
/**
* @brief Copy constructor.
*
* @param[in] inputMethodContext InputMethodContext to copy. The copied inputMethodContext will point at the same implementation.
*/
- InputMethodContext( const InputMethodContext& inputMethodContext );
+ InputMethodContext(const InputMethodContext& inputMethodContext);
/**
* @brief Assignment operator.
* @param[in] inputMethodContext The InputMethodContext to assign from.
* @return The updated InputMethodContext.
*/
- InputMethodContext& operator=( const InputMethodContext& inputMethodContext );
+ InputMethodContext& operator=(const InputMethodContext& inputMethodContext);
/**
* @brief Downcast a handle to InputMethodContext handle.
* @param[in] handle Handle to an object.
* @return Handle to an InputMethodContext or an uninitialized handle.
*/
- static InputMethodContext DownCast( BaseHandle handle );
+ static InputMethodContext DownCast(BaseHandle handle);
public:
-
/**
* @brief Finalize the InputMethodContext.
*
*
* @param[in] toggle True means that keyboard should be restored after focus lost and regained.
*/
- void SetRestoreAfterFocusLost( bool toggle );
+ void SetRestoreAfterFocusLost(bool toggle);
/**
* @brief Send message reset the pred-edit state / InputMethodContext module.
*
* @param[in] cursorPosition position of cursor
*/
- void SetCursorPosition( unsigned int cursorPosition );
+ void SetCursorPosition(unsigned int cursorPosition);
/**
* @brief Gets cursor position stored in VirtualKeyboard, this is required by the InputMethodContext.
*
* @param[in] text The text string surrounding the current cursor point.
*/
- void SetSurroundingText( const std::string& text );
+ void SetSurroundingText(const std::string& text);
/**
* @brief Gets current text string set within the InputMethodContext manager, this is used to offer predictive suggestions.
*
* @param[in] multiLine True if multiline text input is used
*/
- void NotifyTextInputMultiLine( bool multiLine );
+ void NotifyTextInputMultiLine(bool multiLine);
/**
* @brief Returns text direction of the keyboard's current input language.
* @brief Set one or more of the Input Method options
* @param[in] options The options to be applied
*/
- void ApplyOptions( const InputMethodOptions& options );
+ void ApplyOptions(const InputMethodOptions& options);
/**
* @brief Sets up the input-panel specific data.
* @param[in] data The specific data to be set to the input panel
*/
- void SetInputPanelData( const std::string& data );
+ void SetInputPanelData(const std::string& data);
/**
* @brief Gets the specific data of the current active input panel.
* It is just used to get a specific data from the input panel to an application.
* @param[in] data The specific data to be got from the input panel
*/
- void GetInputPanelData( std::string& data );
+ void GetInputPanelData(std::string& data);
/**
* @brief Gets the state of the current active input panel.
* The default is true.
* @param[in] visible True if the return key is visible(enabled), false otherwise.
*/
- void SetReturnKeyState( bool visible );
+ void SetReturnKeyState(bool visible);
/**
* @brief Enable to show the input panel automatically when focused.
* @param[in] enabled If true, the input panel will be shown when focused
*/
- void AutoEnableInputPanel( bool enabled );
+ void AutoEnableInputPanel(bool enabled);
/**
* @brief Shows the input panel.
* You can receive a media content URI and its MIME type from ContentReceivedSignal(). @see ContentReceivedSignal
* @param[in] mimeTypes The allowed MIME types
*/
- void SetContentMIMETypes( const std::string& mimeTypes );
+ void SetContentMIMETypes(const std::string& mimeTypes);
/**
* @brief Process event key down or up, whether filter a key to isf.
* @param[in] keyEvent The event key to be handled.
* @return Whether the event key is handled.
*/
- bool FilterEventKey( const Dali::KeyEvent& keyEvent );
+ bool FilterEventKey(const Dali::KeyEvent& keyEvent);
/**
* @brief Sets whether the IM context should allow to use the text prediction.
*
* @param[in] prediction Whether to allow text prediction or not.
*/
- void AllowTextPrediction( bool prediction );
+ void AllowTextPrediction(bool prediction);
/**
* @brief Gets whether the IM context allow to use the text prediction.
* This method can be used when you want to show the English keyboard.
* @param[in] language The language to be set to the input panel
*/
- void SetInputPanelLanguage( InputPanelLanguage language );
+ void SetInputPanelLanguage(InputPanelLanguage language);
/**
* @brief Gets the language of the input panel.
* @param[in] x The top-left x coordinate of the input panel
* @param[in] y The top-left y coordinate of the input panel
*/
- void SetInputPanelPosition( unsigned int x, unsigned int y );
+ void SetInputPanelPosition(unsigned int x, unsigned int y);
/**
* @brief Gets the preedit attributes data.
*
* @param[out] attrs The preedit attributes data.
*/
- void GetPreeditStyle( PreEditAttributeDataContainer& attrs ) const;
+ void GetPreeditStyle(PreEditAttributeDataContainer& attrs) const;
public:
-
// Signals
/**
ContentReceivedSignalType& ContentReceivedSignal();
public:
-
/**
* @brief This constructor is used by InputMethodContext::New().
*
* @param[in] inputMethodContext A pointer to the InputMethodContext.
*/
- explicit DALI_INTERNAL InputMethodContext( Internal::Adaptor::InputMethodContext* inputMethodContext );
-
+ explicit DALI_INTERNAL InputMethodContext(Internal::Adaptor::InputMethodContext* inputMethodContext);
};
-
-
} // namespace Dali
#endif // DALI_INPUT_METHOD_CONTEXT_H
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
#define TOKEN_STRING(x) #x
struct InputMethodOptions::Impl
{
Impl()
{
- mPanelLayout = PanelLayout::NORMAL;
- mAutoCapital = AutoCapital::SENTENCE;
+ mPanelLayout = PanelLayout::NORMAL;
+ mAutoCapital = AutoCapital::SENTENCE;
mButtonAction = ButtonAction::DEFAULT;
- mVariation = NormalLayout::NORMAL;
+ mVariation = NormalLayout::NORMAL;
}
- PanelLayout::Type mPanelLayout;
- AutoCapital::Type mAutoCapital;
+ PanelLayout::Type mPanelLayout;
+ AutoCapital::Type mAutoCapital;
ButtonAction::Type mButtonAction;
- int mVariation:4;
+ int mVariation : 4;
};
InputMethodOptions::InputMethodOptions()
return (mImpl->mPanelLayout == Dali::InputMethod::PanelLayout::PASSWORD);
}
-void InputMethodOptions::ApplyProperty( const Property::Map& settings )
+void InputMethodOptions::ApplyProperty(const Property::Map& settings)
{
- for ( unsigned int i = 0, count = settings.Count(); i < count; ++i )
+ for(unsigned int i = 0, count = settings.Count(); i < count; ++i)
{
- Property::Key key = settings.GetKeyAt( i );
- if( key.type == Property::Key::INDEX )
+ Property::Key key = settings.GetKeyAt(i);
+ if(key.type == Property::Key::INDEX)
{
continue;
}
Property::Value item = settings.GetValue(i);
- if( key == TOKEN_STRING( PANEL_LAYOUT ) )
+ if(key == TOKEN_STRING(PANEL_LAYOUT))
{
- if( item.GetType() == Property::INTEGER )
+ if(item.GetType() == Property::INTEGER)
{
- int value = item.Get< int >();
+ int value = item.Get<int>();
mImpl->mPanelLayout = static_cast<InputMethod::PanelLayout::Type>(value);
}
}
- else if ( key == TOKEN_STRING( BUTTON_ACTION ) )
+ else if(key == TOKEN_STRING(BUTTON_ACTION))
{
- if ( item.GetType() == Property::INTEGER )
+ if(item.GetType() == Property::INTEGER)
{
- int value = item.Get< int >();
+ int value = item.Get<int>();
mImpl->mButtonAction = static_cast<InputMethod::ButtonAction::Type>(value);
}
}
- else if ( key == TOKEN_STRING( AUTO_CAPITALIZE ) )
+ else if(key == TOKEN_STRING(AUTO_CAPITALIZE))
{
- if ( item.GetType() == Property::INTEGER )
+ if(item.GetType() == Property::INTEGER)
{
- int value = item.Get< int >();
+ int value = item.Get<int>();
mImpl->mAutoCapital = static_cast<InputMethod::AutoCapital::Type>(value);
}
}
- else if( key == TOKEN_STRING( VARIATION ) )
+ else if(key == TOKEN_STRING(VARIATION))
{
- if( item.GetType() == Property::INTEGER )
+ if(item.GetType() == Property::INTEGER)
{
- int value = item.Get< int >();
+ int value = item.Get<int>();
mImpl->mVariation = value;
}
}
}
}
-void InputMethodOptions::RetrieveProperty( Property::Map& settings )
+void InputMethodOptions::RetrieveProperty(Property::Map& settings)
{
- settings[TOKEN_STRING( PANEL_LAYOUT )] = mImpl->mPanelLayout;
- settings[TOKEN_STRING( BUTTON_ACTION )] = mImpl->mButtonAction;
- settings[TOKEN_STRING( AUTO_CAPITALIZE )] = mImpl->mAutoCapital;
- settings[TOKEN_STRING( VARIATION )] = mImpl->mVariation;
+ settings[TOKEN_STRING(PANEL_LAYOUT)] = mImpl->mPanelLayout;
+ settings[TOKEN_STRING(BUTTON_ACTION)] = mImpl->mButtonAction;
+ settings[TOKEN_STRING(AUTO_CAPITALIZE)] = mImpl->mAutoCapital;
+ settings[TOKEN_STRING(VARIATION)] = mImpl->mVariation;
}
-bool InputMethodOptions::CompareAndSet( InputMethod::Category::Type type, const InputMethodOptions& options, int& index)
+bool InputMethodOptions::CompareAndSet(InputMethod::Category::Type type, const InputMethodOptions& options, int& index)
{
bool updated = false;
- switch (type)
+ switch(type)
{
case PANEL_LAYOUT:
{
- if ( options.mImpl->mPanelLayout != mImpl->mPanelLayout )
+ if(options.mImpl->mPanelLayout != mImpl->mPanelLayout)
{
mImpl->mPanelLayout = options.mImpl->mPanelLayout;
- index = static_cast<int>(mImpl->mPanelLayout);
- updated = true;
+ index = static_cast<int>(mImpl->mPanelLayout);
+ updated = true;
}
break;
}
case BUTTON_ACTION:
{
- if ( options.mImpl->mButtonAction != mImpl->mButtonAction )
+ if(options.mImpl->mButtonAction != mImpl->mButtonAction)
{
mImpl->mButtonAction = options.mImpl->mButtonAction;
- index = static_cast<int>(mImpl->mButtonAction);
- updated = true;
+ index = static_cast<int>(mImpl->mButtonAction);
+ updated = true;
}
break;
}
case AUTO_CAPITALIZE:
{
- if ( options.mImpl->mAutoCapital != mImpl->mAutoCapital )
+ if(options.mImpl->mAutoCapital != mImpl->mAutoCapital)
{
mImpl->mAutoCapital = options.mImpl->mAutoCapital;
- index = static_cast<int>(mImpl->mAutoCapital);
- updated = true;
+ index = static_cast<int>(mImpl->mAutoCapital);
+ updated = true;
}
break;
}
case VARIATION:
{
- if ( options.mImpl->mVariation != mImpl->mVariation )
+ if(options.mImpl->mVariation != mImpl->mVariation)
{
mImpl->mVariation = options.mImpl->mVariation;
- index = static_cast<int>(mImpl->mVariation);
- updated = true;
+ index = static_cast<int>(mImpl->mVariation);
+ updated = true;
}
break;
}
#define DALI_VIRTUAL_KEYBOARD_OPTIONS_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
/**
* Class to handle the Input Method options
*/
class DALI_ADAPTOR_API InputMethodOptions
{
public:
-
/**
* Constructor
*/
- InputMethodOptions(); /// Default InputMethodOptions options
+ InputMethodOptions(); /// Default InputMethodOptions options
/**
* Destructor
* @brief Apply property map to attribute class, this class will keep the virtualKeyboard settings.
* @param[in] settings The property map to be applied
*/
- void ApplyProperty( const Property::Map& settings );
+ void ApplyProperty(const Property::Map& settings);
/**
* @brief Retrieve property map from current option
* @param[out] settings The converted property map
*/
- void RetrieveProperty( Property::Map& settings );
+ void RetrieveProperty(Property::Map& settings);
public: // Intended for internal use
/**
* @param[out] index The updated index after applying source option
* @return true if the value of this option is updated by source option
*/
- DALI_INTERNAL bool CompareAndSet( InputMethod::Category::Type type, const InputMethodOptions& options, int& index );
+ DALI_INTERNAL bool CompareAndSet(InputMethod::Category::Type type, const InputMethodOptions& options, int& index);
private:
-
struct Impl;
std::unique_ptr<Impl> mImpl;
};
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace DevelKey
{
-
-int GetDaliKeyCode( const char* keyName )
+int GetDaliKeyCode(const char* keyName)
{
- return Internal::Adaptor::KeyLookup::GetDaliKeyCode( keyName );
+ return Internal::Adaptor::KeyLookup::GetDaliKeyCode(keyName);
}
} // namespace DevelKey
#define DALI_KEY_DEVEL_H
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace DevelKey
{
-
enum Key
{
- DALI_KEY_INVALID = Dali::DALI_KEY_INVALID,
- DALI_KEY_ESCAPE = Dali::DALI_KEY_ESCAPE,
- DALI_KEY_BACKSPACE = Dali::DALI_KEY_BACKSPACE,
- DALI_KEY_SHIFT_LEFT = Dali::DALI_KEY_SHIFT_LEFT,
- DALI_KEY_SHIFT_RIGHT = Dali::DALI_KEY_SHIFT_RIGHT,
- DALI_KEY_CURSOR_UP = Dali::DALI_KEY_CURSOR_UP,
- DALI_KEY_CURSOR_LEFT = Dali::DALI_KEY_CURSOR_LEFT,
- DALI_KEY_CURSOR_RIGHT = Dali::DALI_KEY_CURSOR_RIGHT,
- DALI_KEY_CURSOR_DOWN = Dali::DALI_KEY_CURSOR_DOWN,
- DALI_KEY_BACK = Dali::DALI_KEY_BACK,
- DALI_KEY_CAMERA = Dali::DALI_KEY_CAMERA,
- DALI_KEY_CONFIG = Dali::DALI_KEY_CONFIG,
- DALI_KEY_POWER = Dali::DALI_KEY_POWER,
- DALI_KEY_PAUSE = Dali::DALI_KEY_PAUSE,
- DALI_KEY_CANCEL = Dali::DALI_KEY_CANCEL,
- DALI_KEY_PLAY_CD = Dali::DALI_KEY_PLAY_CD,
- DALI_KEY_STOP_CD = Dali::DALI_KEY_STOP_CD,
- DALI_KEY_PAUSE_CD = Dali::DALI_KEY_PAUSE_CD,
- DALI_KEY_NEXT_SONG = Dali::DALI_KEY_NEXT_SONG,
- DALI_KEY_PREVIOUS_SONG = Dali::DALI_KEY_PREVIOUS_SONG,
- DALI_KEY_REWIND = Dali::DALI_KEY_REWIND,
- DALI_KEY_FASTFORWARD = Dali::DALI_KEY_FASTFORWARD,
- DALI_KEY_MEDIA = Dali::DALI_KEY_MEDIA,
- DALI_KEY_PLAY_PAUSE = Dali::DALI_KEY_PLAY_PAUSE,
- DALI_KEY_MUTE = Dali::DALI_KEY_MUTE,
- DALI_KEY_MENU = Dali::DALI_KEY_MENU,
- DALI_KEY_HOME = Dali::DALI_KEY_HOME,
- DALI_KEY_HOMEPAGE = Dali::DALI_KEY_HOMEPAGE,
- DALI_KEY_WEBPAGE = Dali::DALI_KEY_WEBPAGE,
- DALI_KEY_MAIL = Dali::DALI_KEY_MAIL,
- DALI_KEY_SCREENSAVER = Dali::DALI_KEY_SCREENSAVER,
- DALI_KEY_BRIGHTNESS_UP = Dali::DALI_KEY_BRIGHTNESS_UP,
+ DALI_KEY_INVALID = Dali::DALI_KEY_INVALID,
+ DALI_KEY_ESCAPE = Dali::DALI_KEY_ESCAPE,
+ DALI_KEY_BACKSPACE = Dali::DALI_KEY_BACKSPACE,
+ DALI_KEY_SHIFT_LEFT = Dali::DALI_KEY_SHIFT_LEFT,
+ DALI_KEY_SHIFT_RIGHT = Dali::DALI_KEY_SHIFT_RIGHT,
+ DALI_KEY_CURSOR_UP = Dali::DALI_KEY_CURSOR_UP,
+ DALI_KEY_CURSOR_LEFT = Dali::DALI_KEY_CURSOR_LEFT,
+ DALI_KEY_CURSOR_RIGHT = Dali::DALI_KEY_CURSOR_RIGHT,
+ DALI_KEY_CURSOR_DOWN = Dali::DALI_KEY_CURSOR_DOWN,
+ DALI_KEY_BACK = Dali::DALI_KEY_BACK,
+ DALI_KEY_CAMERA = Dali::DALI_KEY_CAMERA,
+ DALI_KEY_CONFIG = Dali::DALI_KEY_CONFIG,
+ DALI_KEY_POWER = Dali::DALI_KEY_POWER,
+ DALI_KEY_PAUSE = Dali::DALI_KEY_PAUSE,
+ DALI_KEY_CANCEL = Dali::DALI_KEY_CANCEL,
+ DALI_KEY_PLAY_CD = Dali::DALI_KEY_PLAY_CD,
+ DALI_KEY_STOP_CD = Dali::DALI_KEY_STOP_CD,
+ DALI_KEY_PAUSE_CD = Dali::DALI_KEY_PAUSE_CD,
+ DALI_KEY_NEXT_SONG = Dali::DALI_KEY_NEXT_SONG,
+ DALI_KEY_PREVIOUS_SONG = Dali::DALI_KEY_PREVIOUS_SONG,
+ DALI_KEY_REWIND = Dali::DALI_KEY_REWIND,
+ DALI_KEY_FASTFORWARD = Dali::DALI_KEY_FASTFORWARD,
+ DALI_KEY_MEDIA = Dali::DALI_KEY_MEDIA,
+ DALI_KEY_PLAY_PAUSE = Dali::DALI_KEY_PLAY_PAUSE,
+ DALI_KEY_MUTE = Dali::DALI_KEY_MUTE,
+ DALI_KEY_MENU = Dali::DALI_KEY_MENU,
+ DALI_KEY_HOME = Dali::DALI_KEY_HOME,
+ DALI_KEY_HOMEPAGE = Dali::DALI_KEY_HOMEPAGE,
+ DALI_KEY_WEBPAGE = Dali::DALI_KEY_WEBPAGE,
+ DALI_KEY_MAIL = Dali::DALI_KEY_MAIL,
+ DALI_KEY_SCREENSAVER = Dali::DALI_KEY_SCREENSAVER,
+ DALI_KEY_BRIGHTNESS_UP = Dali::DALI_KEY_BRIGHTNESS_UP,
DALI_KEY_BRIGHTNESS_DOWN = Dali::DALI_KEY_BRIGHTNESS_DOWN,
- DALI_KEY_SOFT_KBD = Dali::DALI_KEY_SOFT_KBD,
- DALI_KEY_QUICK_PANEL = Dali::DALI_KEY_QUICK_PANEL,
- DALI_KEY_TASK_SWITCH = Dali::DALI_KEY_TASK_SWITCH,
- DALI_KEY_APPS = Dali::DALI_KEY_APPS,
- DALI_KEY_SEARCH = Dali::DALI_KEY_SEARCH,
- DALI_KEY_VOICE = Dali::DALI_KEY_VOICE,
- DALI_KEY_LANGUAGE = Dali::DALI_KEY_LANGUAGE,
- DALI_KEY_VOLUME_UP = Dali::DALI_KEY_VOLUME_UP,
- DALI_KEY_VOLUME_DOWN = Dali::DALI_KEY_VOLUME_DOWN,
+ DALI_KEY_SOFT_KBD = Dali::DALI_KEY_SOFT_KBD,
+ DALI_KEY_QUICK_PANEL = Dali::DALI_KEY_QUICK_PANEL,
+ DALI_KEY_TASK_SWITCH = Dali::DALI_KEY_TASK_SWITCH,
+ DALI_KEY_APPS = Dali::DALI_KEY_APPS,
+ DALI_KEY_SEARCH = Dali::DALI_KEY_SEARCH,
+ DALI_KEY_VOICE = Dali::DALI_KEY_VOICE,
+ DALI_KEY_LANGUAGE = Dali::DALI_KEY_LANGUAGE,
+ DALI_KEY_VOLUME_UP = Dali::DALI_KEY_VOLUME_UP,
+ DALI_KEY_VOLUME_DOWN = Dali::DALI_KEY_VOLUME_DOWN,
/**
* @brief Delete key.
* @param[in] keyName The key name
* @return The key code. -1 if the daliKey does not exist in the supported key lookup table.
*/
-DALI_ADAPTOR_API int GetDaliKeyCode( const char* keyName );
+DALI_ADAPTOR_API int GetDaliKeyCode(const char* keyName);
} // namespace DevelKey
#define DALI_KEY_EXTENSION_PLUGIN_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
/**
* @brief KeyExtensionPlugin is an abstract interface, used by dali-adaptor to access key extension plugin.
* A concrete implementation must be created for each platform and provided as dynamic library.
class KeyExtensionPlugin
{
public:
-
struct KeyLookup
{
- const char* keyName; ///< XF86 key name
- const int daliKeyCode; ///< Dali key code
- const bool deviceButton; ///< Whether the key is from a button on the device
+ const char* keyName; ///< XF86 key name
+ const int daliKeyCode; ///< Dali key code
+ const bool deviceButton; ///< Whether the key is from a button on the device
};
/**
* @brief Constructor.
* @SINCE_1_2.41
*/
- KeyExtensionPlugin(){}
+ KeyExtensionPlugin()
+ {
+ }
/**
* @brief Destructor.
* @SINCE_1_2.41
*/
- virtual ~KeyExtensionPlugin(){}
+ virtual ~KeyExtensionPlugin()
+ {
+ }
/**
* @brief Get extension key lookup table.
virtual std::size_t GetKeyLookupTableCount() = 0;
};
-} // namespace Dali;
+} // namespace Dali
#endif
#define DALI_KEYBOARD_H
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
namespace Keyboard
{
-
/**
* @brief Sets keyboard repeat information.
*
* @param[in] delay The key repeat delay value in seconds
* @return true if setting the keyboard repeat succeeds
*/
-DALI_ADAPTOR_API bool SetRepeatInfo( float rate, float delay );
-
+DALI_ADAPTOR_API bool SetRepeatInfo(float rate, float delay);
/**
* @brief Gets keyboard repeat information.
* @param[in] delay The key repeat delay value in seconds
* @return true if getting the keyboard repeat succeeds, false otherwise
*/
-DALI_ADAPTOR_API bool GetRepeatInfo( float& rate, float& delay );
+DALI_ADAPTOR_API bool GetRepeatInfo(float& rate, float& delay);
} // namespace Keyboard
namespace Dali
{
-
LifecycleController::LifecycleController()
{
}
LifecycleController& LifecycleController::operator=(const LifecycleController& monitor)
{
- if( *this != monitor )
+ if(*this != monitor)
{
BaseHandle::operator=(monitor);
}
namespace Dali
{
-
namespace Internal DALI_INTERNAL
{
namespace Adaptor
{
class LifecycleController;
}
-}
+} // namespace DALI_INTERNAL
/**
* @brief Provides application lifecycle events.
*/
class DALI_ADAPTOR_API LifecycleController : public BaseHandle
{
-public: // Typedefs
-
- typedef Signal< void (void) > LifecycleSignalType; ///< Lifecycle Signal type
+public: // Typedefs
+ typedef Signal<void(void)> LifecycleSignalType; ///< Lifecycle Signal type
public: // Creation & Destruction
-
/**
* @brief Create an uninitialized LifecycleController handle.
*
~LifecycleController();
public: // Signals
-
/**
* The user should connect to this signal to determine when they should initialise
* their application.
LifecycleSignalType& LanguageChangedSignal();
public: // Operators
-
/**
* @brief Assignment operator.
*
//INTERNAL INCLUDES\r
#include <dali/internal/imaging/common/native-image-source-impl.h>\r
\r
-\r
namespace Dali\r
{\r
-\r
namespace DevelNativeImageSource\r
{\r
-\r
-bool EncodeToFile( NativeImageSource& image, const std::string& filename, const uint32_t quality )\r
+bool EncodeToFile(NativeImageSource& image, const std::string& filename, const uint32_t quality)\r
{\r
- return Dali::Internal::Adaptor::NativeImageSource::GetImplementation( image ).EncodeToFile( filename, quality );\r
+ return Dali::Internal::Adaptor::NativeImageSource::GetImplementation(image).EncodeToFile(filename, quality);\r
}\r
\r
-uint8_t* AcquireBuffer( NativeImageSource& image, uint16_t& width, uint16_t& height, uint16_t& stride )\r
+uint8_t* AcquireBuffer(NativeImageSource& image, uint16_t& width, uint16_t& height, uint16_t& stride)\r
{\r
- return Dali::Internal::Adaptor::NativeImageSource::GetImplementation( image ).AcquireBuffer( width, height, stride );\r
+ return Dali::Internal::Adaptor::NativeImageSource::GetImplementation(image).AcquireBuffer(width, height, stride);\r
}\r
\r
-bool ReleaseBuffer( NativeImageSource& image )\r
+bool ReleaseBuffer(NativeImageSource& image)\r
{\r
- return Dali::Internal::Adaptor::NativeImageSource::GetImplementation( image ).ReleaseBuffer();\r
+ return Dali::Internal::Adaptor::NativeImageSource::GetImplementation(image).ReleaseBuffer();\r
}\r
\r
} // namespace DevelNativeImageSource\r
\r
namespace Dali\r
{\r
-\r
namespace DevelNativeImageSource\r
{\r
-\r
/**\r
* @brief Converts the current pixel contents to either a JPEG or PNG format\r
* and write that to the filesystem.\r
* @param[in] quality The value to control image quality for jpeg file format in the range [1, 100]\r
* @return @c true if the pixels were written, and @c false otherwise\r
*/\r
-DALI_ADAPTOR_API bool EncodeToFile( NativeImageSource& image, const std::string& filename, const uint32_t quality );\r
+DALI_ADAPTOR_API bool EncodeToFile(NativeImageSource& image, const std::string& filename, const uint32_t quality);\r
\r
/**\r
* @brief Acquire buffer and information of an internal native image.\r
* @param[out] stride The stride of image\r
* @return The buffer of an internal native image\r
*/\r
-DALI_ADAPTOR_API uint8_t* AcquireBuffer( NativeImageSource& image, uint16_t& width, uint16_t& height, uint16_t& stride );\r
+DALI_ADAPTOR_API uint8_t* AcquireBuffer(NativeImageSource& image, uint16_t& width, uint16_t& height, uint16_t& stride);\r
\r
/**\r
* @brief Release information of an internal native image.\r
* @param[in] image The instance of NativeImageSource.\r
* @return @c true If the buffer is released successfully, and @c false otherwise\r
*/\r
-DALI_ADAPTOR_API bool ReleaseBuffer( NativeImageSource& image );\r
+DALI_ADAPTOR_API bool ReleaseBuffer(NativeImageSource& image);\r
\r
} // namespace DevelNativeImageSource\r
\r
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
#include <dali/devel-api/adaptor-framework/native-image-source-queue.h>
// INTERNAL INCLUDES
-#include <dali/internal/imaging/common/native-image-source-queue-impl.h>
#include <dali/internal/imaging/common/native-image-source-factory.h>
+#include <dali/internal/imaging/common/native-image-source-queue-impl.h>
namespace Dali
{
-
-NativeImageSourceQueuePtr NativeImageSourceQueue::New( uint32_t width, uint32_t height, ColorDepth depth )
+NativeImageSourceQueuePtr NativeImageSourceQueue::New(uint32_t width, uint32_t height, ColorDepth depth)
{
- Any empty;
- NativeImageSourceQueuePtr image = new NativeImageSourceQueue( width, height, depth, empty );
- if( image->mImpl )
+ Any empty;
+ NativeImageSourceQueuePtr image = new NativeImageSourceQueue(width, height, depth, empty);
+ if(image->mImpl)
{
return image;
}
return nullptr;
}
-NativeImageSourceQueuePtr NativeImageSourceQueue::New( Any nativeImageSourceQueue )
+NativeImageSourceQueuePtr NativeImageSourceQueue::New(Any nativeImageSourceQueue)
{
- NativeImageSourceQueuePtr image = new NativeImageSourceQueue( 0, 0, COLOR_DEPTH_DEFAULT, nativeImageSourceQueue );
- if( image->mImpl )
+ NativeImageSourceQueuePtr image = new NativeImageSourceQueue(0, 0, COLOR_DEPTH_DEFAULT, nativeImageSourceQueue);
+ if(image->mImpl)
{
return image;
}
return mImpl->GetNativeImageSourceQueue();
}
-void NativeImageSourceQueue::SetSize( uint32_t width, uint32_t height )
+void NativeImageSourceQueue::SetSize(uint32_t width, uint32_t height)
{
- return mImpl->SetSize( width, height );
+ return mImpl->SetSize(width, height);
}
void NativeImageSourceQueue::IgnoreSourceImage()
return mImpl->GetNativeImageInterfaceExtension();
}
-NativeImageSourceQueue::NativeImageSourceQueue( uint32_t width, uint32_t height, ColorDepth depth, Any nativeImageSourceQueue )
+NativeImageSourceQueue::NativeImageSourceQueue(uint32_t width, uint32_t height, ColorDepth depth, Any nativeImageSourceQueue)
{
auto factory = Dali::Internal::Adaptor::GetNativeImageSourceFactory();
- mImpl = factory->CreateNativeImageSourceQueue( width, height, depth, nativeImageSourceQueue );
+ mImpl = factory->CreateNativeImageSourceQueue(width, height, depth, nativeImageSourceQueue);
}
NativeImageSourceQueue::~NativeImageSourceQueue()
#define DALI_NATIVE_IMAGE_SOURCE_QUEUE_H
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
{
class NativeImageSourceQueue;
}
-}
+} // namespace DALI_INTERNAL
class NativeImageSourceQueue;
/**
* @brief Pointer to Dali::NativeImageSourceQueue.
*/
-typedef Dali::IntrusivePtr< Dali::NativeImageSourceQueue > NativeImageSourceQueuePtr;
+typedef Dali::IntrusivePtr<Dali::NativeImageSourceQueue> NativeImageSourceQueuePtr;
/**
* @brief Used for displaying native images.
class DALI_ADAPTOR_API NativeImageSourceQueue : public NativeImageInterface
{
public:
-
- /**
+ /**
* @brief Enumeration for the instance when creating a native image, the color depth has to be specified.
*/
- enum ColorDepth
- {
- COLOR_DEPTH_DEFAULT, ///< Uses the current screen default depth (recommended)
- COLOR_DEPTH_24, ///< 24 bits per pixel
- COLOR_DEPTH_32 ///< 32 bits per pixel
- };
+ enum ColorDepth
+ {
+ COLOR_DEPTH_DEFAULT, ///< Uses the current screen default depth (recommended)
+ COLOR_DEPTH_24, ///< 24 bits per pixel
+ COLOR_DEPTH_32 ///< 32 bits per pixel
+ };
/**
* @brief Creates a new NativeImageSourceQueue.
* @param[in] depth color depth of the image
* @return A smart-pointer to a newly allocated image
*/
- static NativeImageSourceQueuePtr New( uint32_t width, uint32_t height, ColorDepth depth );
+ static NativeImageSourceQueuePtr New(uint32_t width, uint32_t height, ColorDepth depth);
/**
* @brief Creates a new NativeImageSourceQueue from an existing native image source.
* @return A smart-pointer to a newly allocated image
* @see NativeImageInterface
*/
- static NativeImageSourceQueuePtr New( Any nativeImageSourceQueue );
+ static NativeImageSourceQueuePtr New(Any nativeImageSourceQueue);
/**
* @brief Retrieves the internal native image.
* @param[in] width The width of the image
* @param[in] height The height of the image
*/
- void SetSize( uint32_t width, uint32_t height );
+ void SetSize(uint32_t width, uint32_t height);
/**
* @brief Ignores a source image which is inserted to the queue.
*/
const char* GetCustomSamplerTypename() const override;
-
-private: // native image
-
+private: // native image
/**
* @copydoc Dali::NativeImageInterface::CreateResource()
*/
NativeImageInterface::Extension* GetExtension() override;
private:
-
/// @cond internal
/**
* @brief Private constructor.
* @param[in] depth color depth of the image
* @param[in] nativeImageSourceQueue contains either: native image source or is empty
*/
- DALI_INTERNAL NativeImageSourceQueue( uint32_t width, uint32_t height, ColorDepth depth, Any nativeImageSourceQueue );
+ DALI_INTERNAL NativeImageSourceQueue(uint32_t width, uint32_t height, ColorDepth depth, Any nativeImageSourceQueue);
/**
* @brief A reference counted object may only be deleted by calling Unreference().
* This avoids accidental calls to a default copy constructor.
* @param[in] nativeImageSourceQueue A reference to the object to copy
*/
- DALI_INTERNAL NativeImageSourceQueue( const NativeImageSourceQueue& nativeImageSourceQueue );
+ DALI_INTERNAL NativeImageSourceQueue(const NativeImageSourceQueue& nativeImageSourceQueue);
/**
* @brief Undefined assignment operator.
/// @endcond
private:
-
/// @cond internal
- std::unique_ptr< Internal::Adaptor::NativeImageSourceQueue > mImpl; ///< Implementation pointer
+ std::unique_ptr<Internal::Adaptor::NativeImageSourceQueue> mImpl; ///< Implementation pointer
/// @endcond
};
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
Orientation::Orientation()
{
}
return Internal::Adaptor::GetImplementation(*this).ChangedSignal();
}
-Orientation::Orientation( Internal::Adaptor::Orientation* orientation )
+Orientation::Orientation(Internal::Adaptor::Orientation* orientation)
: BaseHandle(orientation)
{
}
#define DALI_ORIENTATION_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
// EXTERNAL INCLUDES
-#include <dali/public-api/signals/dali-signal.h>
#include <dali/public-api/object/base-handle.h>
+#include <dali/public-api/signals/dali-signal.h>
// INTERNAL INCLUDES
#include <dali/public-api/dali-adaptor-common.h>
namespace Dali
{
-
namespace Internal DALI_INTERNAL
{
namespace Adaptor
{
class Orientation;
}
-}
+} // namespace DALI_INTERNAL
/**
* @brief Orientation allows the user to determine the orientation of the device.
class DALI_ADAPTOR_API Orientation : public BaseHandle
{
public:
-
- typedef Signal< void (Orientation) > OrientationSignalType; ///< Orientation changed signal type
+ typedef Signal<void(Orientation)> OrientationSignalType; ///< Orientation changed signal type
/**
* @brief Create an unintialized handle.
*
* @param[in] orientation A pointer to the orientation object
*/
- explicit DALI_INTERNAL Orientation( Internal::Adaptor::Orientation* orientation );
+ explicit DALI_INTERNAL Orientation(Internal::Adaptor::Orientation* orientation);
};
} // namespace Dali
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
PerformanceLogger::PerformanceLogger()
{
}
-PerformanceLogger PerformanceLogger::New( const char* name )
+PerformanceLogger PerformanceLogger::New(const char* name)
{
- Internal::Adaptor::PerformanceLoggerPtr internal = Internal::Adaptor::PerformanceLogger::New( name );
+ Internal::Adaptor::PerformanceLoggerPtr internal = Internal::Adaptor::PerformanceLogger::New(name);
return PerformanceLogger(internal.Get());
}
-PerformanceLogger::PerformanceLogger( const PerformanceLogger& performanceLogger )
+PerformanceLogger::PerformanceLogger(const PerformanceLogger& performanceLogger)
: BaseHandle(performanceLogger)
{
}
-PerformanceLogger& PerformanceLogger::operator=( const PerformanceLogger& performanceLogger )
+PerformanceLogger& PerformanceLogger::operator=(const PerformanceLogger& performanceLogger)
{
// check self assignment
- if( *this != performanceLogger )
+ if(*this != performanceLogger)
{
BaseHandle::operator=(performanceLogger);
}
{
}
-PerformanceLogger PerformanceLogger::DownCast( BaseHandle handle )
+PerformanceLogger PerformanceLogger::DownCast(BaseHandle handle)
{
- return PerformanceLogger( dynamic_cast<Internal::Adaptor::PerformanceLogger*>( handle.GetObjectPtr() ) );
+ return PerformanceLogger(dynamic_cast<Internal::Adaptor::PerformanceLogger*>(handle.GetObjectPtr()));
}
-void PerformanceLogger::AddMarker( Marker markerType )
+void PerformanceLogger::AddMarker(Marker markerType)
{
- Internal::Adaptor::GetImplementation(*this).AddMarker( markerType );
+ Internal::Adaptor::GetImplementation(*this).AddMarker(markerType);
}
-void PerformanceLogger::SetLoggingFrequency( unsigned int logFrequency)
+void PerformanceLogger::SetLoggingFrequency(unsigned int logFrequency)
{
- Internal::Adaptor::GetImplementation(*this).SetLoggingFrequency( logFrequency );
+ Internal::Adaptor::GetImplementation(*this).SetLoggingFrequency(logFrequency);
}
-void PerformanceLogger::EnableLogging( bool enable )
+void PerformanceLogger::EnableLogging(bool enable)
{
- Internal::Adaptor::GetImplementation(*this).EnableLogging( enable );
+ Internal::Adaptor::GetImplementation(*this).EnableLogging(enable);
}
PerformanceLogger::PerformanceLogger(Internal::Adaptor::PerformanceLogger* PerformanceLogger)
#define DALI_PERFORMANCE_LOGGER_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Internal DALI_INTERNAL
{
namespace Adaptor
{
class PerformanceLogger;
}
-}
+} // namespace DALI_INTERNAL
/**
* @brief Performance logger class
class DALI_ADAPTOR_API PerformanceLogger : public BaseHandle
{
public:
-
/**
* Enum for events that can be logged
*/
enum Marker
{
- START_EVENT, ///< The start of timing
- END_EVENT ///< The end of timing
+ START_EVENT, ///< The start of timing
+ END_EVENT ///< The end of timing
};
/**
* @param[in] name The name of the logger. This needs to be a compile-time literal and alive for the whole lifetime of the performance logger.
* @return a new logger
*/
- static PerformanceLogger New( const char* name );
+ static PerformanceLogger New(const char* name);
/**
* @brief Copy constructor.
*
* @param[in] logger The handle to copy. The copied handle will point at the same implementation
*/
- PerformanceLogger( const PerformanceLogger& logger );
+ PerformanceLogger(const PerformanceLogger& logger);
/**
* @brief Assignment operator.
* as the copied handle.
* @return Reference to this logger handle
*/
- PerformanceLogger& operator=( const PerformanceLogger& logger );
+ PerformanceLogger& operator=(const PerformanceLogger& logger);
/**
* @brief Destructor
* @param[in] handle to An object
* @return handle to a PerformanceLogger object or an uninitialized handle
*/
- static PerformanceLogger DownCast( BaseHandle handle );
+ static PerformanceLogger DownCast(BaseHandle handle);
/**
* Add a performance marker
*
* @param markerType Performance marker type
*/
- void AddMarker( Marker markerType );
+ void AddMarker(Marker markerType);
/**
* Set the logging frequency
*
* @param logFrequency how often to log out in seconds
*/
- void SetLoggingFrequency( unsigned int logFrequency);
+ void SetLoggingFrequency(unsigned int logFrequency);
/**
* Set logging on or off for this logger
*
* @param[in] enable Enable logging or not
*/
- void EnableLogging( bool enable );
+ void EnableLogging(bool enable);
// Not intended for application developers
* Creates a new handle from the implementation.
* @param[in] impl A pointer to the object.
*/
- explicit DALI_INTERNAL PerformanceLogger( Internal::Adaptor::PerformanceLogger* impl );
-
+ explicit DALI_INTERNAL PerformanceLogger(Internal::Adaptor::PerformanceLogger* impl);
};
} // namespace Dali
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
PhysicalKeyboard::PhysicalKeyboard()
{
}
PhysicalKeyboard handle = Internal::Adaptor::PhysicalKeyboard::Get();
// If it's not been created then create one
- if ( !handle )
+ if(!handle)
{
handle = Internal::Adaptor::PhysicalKeyboard::New();
}
bool PhysicalKeyboard::IsAttached() const
{
- return GetImplementation( *this ).IsAttached();
+ return GetImplementation(*this).IsAttached();
}
PhysicalKeyboard::PhysicalKeyboardSignalType& PhysicalKeyboard::StatusChangedSignal()
{
- return GetImplementation( *this ).StatusChangedSignal();
+ return GetImplementation(*this).StatusChangedSignal();
}
-PhysicalKeyboard::PhysicalKeyboard( Internal::Adaptor::PhysicalKeyboard *impl )
+PhysicalKeyboard::PhysicalKeyboard(Internal::Adaptor::PhysicalKeyboard* impl)
: BaseHandle(impl)
{
}
#define DALI_PHYSICAL_KEYBOARD_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Internal DALI_INTERNAL
{
namespace Adaptor
{
class PhysicalKeyboard;
}
-}
+} // namespace DALI_INTERNAL
/**
* This is a handle to a physical keyboard connected to the device.
class DALI_ADAPTOR_API PhysicalKeyboard : public BaseHandle
{
public:
-
- typedef Signal< void (PhysicalKeyboard) > PhysicalKeyboardSignalType;
+ typedef Signal<void(PhysicalKeyboard)> PhysicalKeyboardSignalType;
public:
-
/**
* Create an uninitialized PhysicalKeyboard handle; this can be initialized with GetKeyboard()
* Calling member functions with an uninitialized Dali::Object is not allowed.
* Creates a new handle from the implementation.
* @param[in] impl A pointer to the object.
*/
- explicit DALI_INTERNAL PhysicalKeyboard( Internal::Adaptor::PhysicalKeyboard* impl );
+ explicit DALI_INTERNAL PhysicalKeyboard(Internal::Adaptor::PhysicalKeyboard* impl);
};
} // namespace Dali
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
{
namespace Devel
{
-
-PixelBuffer PixelBuffer::New( unsigned int width,
- unsigned int height,
- Dali::Pixel::Format pixelFormat )
+PixelBuffer PixelBuffer::New(unsigned int width,
+ unsigned int height,
+ Dali::Pixel::Format pixelFormat)
{
Internal::Adaptor::PixelBufferPtr internal =
- Internal::Adaptor::PixelBuffer::New( width, height, pixelFormat );
- return Devel::PixelBuffer( internal.Get() );
+ Internal::Adaptor::PixelBuffer::New(width, height, pixelFormat);
+ return Devel::PixelBuffer(internal.Get());
}
-Dali::PixelData PixelBuffer::Convert( PixelBuffer& pixelBuffer )
+Dali::PixelData PixelBuffer::Convert(PixelBuffer& pixelBuffer)
{
Dali::PixelData pixelData =
- Internal::Adaptor::PixelBuffer::Convert( GetImplementation(pixelBuffer) );
+ Internal::Adaptor::PixelBuffer::Convert(GetImplementation(pixelBuffer));
pixelBuffer.Reset();
return pixelData;
}
return GetImplementation(*this).CreatePixelData();
}
-
PixelBuffer::PixelBuffer()
{
}
{
}
-PixelBuffer::PixelBuffer( Internal::Adaptor::PixelBuffer* internal )
-: BaseHandle( internal )
+PixelBuffer::PixelBuffer(Internal::Adaptor::PixelBuffer* internal)
+: BaseHandle(internal)
{
}
PixelBuffer::PixelBuffer(const PixelBuffer& handle)
-: BaseHandle( handle )
+: BaseHandle(handle)
{
}
return GetImplementation(*this).GetConstBuffer();
}
-void PixelBuffer::ApplyMask( PixelBuffer mask, float contentScale, bool cropToMask )
+void PixelBuffer::ApplyMask(PixelBuffer mask, float contentScale, bool cropToMask)
{
- GetImplementation(*this).ApplyMask( GetImplementation( mask ), contentScale, cropToMask );
+ GetImplementation(*this).ApplyMask(GetImplementation(mask), contentScale, cropToMask);
}
-void PixelBuffer::ApplyGaussianBlur( const float blurRadius )
+void PixelBuffer::ApplyGaussianBlur(const float blurRadius)
{
- GetImplementation(*this).ApplyGaussianBlur( blurRadius );
+ GetImplementation(*this).ApplyGaussianBlur(blurRadius);
}
-void PixelBuffer::Crop( uint16_t x, uint16_t y, uint16_t width, uint16_t height )
+void PixelBuffer::Crop(uint16_t x, uint16_t y, uint16_t width, uint16_t height)
{
- GetImplementation(*this).Crop( x, y, ImageDimensions( width, height ) );
+ GetImplementation(*this).Crop(x, y, ImageDimensions(width, height));
}
-void PixelBuffer::Resize( uint16_t width, uint16_t height )
+void PixelBuffer::Resize(uint16_t width, uint16_t height)
{
- GetImplementation(*this).Resize( ImageDimensions( width, height ) );
+ GetImplementation(*this).Resize(ImageDimensions(width, height));
}
void PixelBuffer::MultiplyColorByAlpha()
GetImplementation(*this).MultiplyColorByAlpha();
}
-bool PixelBuffer::GetMetadata( Property::Map& metadata ) const
+bool PixelBuffer::GetMetadata(Property::Map& metadata) const
{
return GetImplementation(*this).GetMetadata(metadata);
}
-bool PixelBuffer::Rotate( Degree angle )
+bool PixelBuffer::Rotate(Degree angle)
{
- return GetImplementation(*this).Rotate( angle );
+ return GetImplementation(*this).Rotate(angle);
}
bool PixelBuffer::IsAlphaPreMultiplied() const
#define DALI_PIXEL_BUFFER_H
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
// INTERNAL INCLUDES
-#include <dali/public-api/images/pixel.h>
#include <dali/public-api/images/pixel-data.h>
+#include <dali/public-api/images/pixel.h>
#include <dali/public-api/object/base-handle.h>
// INTERNAL INCLUDES
namespace Dali
{
-
namespace Internal
{
namespace Adaptor
{
class PixelBuffer;
}
-}
-
+} // namespace Internal
// Use namespace to separate from PixelBuffer typedef in buffer-image.h
namespace Devel
{
-
/**
* @brief The PixelBuffer object holds a pixel buffer.
*
class DALI_ADAPTOR_API PixelBuffer : public BaseHandle
{
public:
-
/**
* Create a PixelBuffer with it's own data buffer.
*/
- static PixelBuffer New( unsigned int width,
- unsigned int height,
- Dali::Pixel::Format pixelFormat );
+ static PixelBuffer New(unsigned int width,
+ unsigned int height,
+ Dali::Pixel::Format pixelFormat);
/**
* @brief Creates an empty handle.
* @param[in,out] pixelBuffer
* @return a new PixelData which takes ownership of the PixelBuffer's buffer.
*/
- static PixelData Convert( PixelBuffer& pixelBuffer );
+ static PixelData Convert(PixelBuffer& pixelBuffer);
/**
* Copy the data from this object into a new PixelData object, which could be
* @param[in] cropToMask Whether to crop the output to the mask size (true)
* or scale the mask to the content size (false)
*/
- void ApplyMask( PixelBuffer mask, float contentScale=1.0f, bool cropToMask=false );
+ void ApplyMask(PixelBuffer mask, float contentScale = 1.0f, bool cropToMask = false);
/**
* Apply a Gaussian blur to this pixel data with the given radius.
*
* @param[in] blurRadius The radius for Gaussian blur. A value of 0 or negative value indicates no blur.
*/
- void ApplyGaussianBlur( const float blurRadius );
+ void ApplyGaussianBlur(const float blurRadius);
/**
* @brief Crops this buffer to the given crop rectangle.
* @param[in] width The crop width
* @param[in] height The crop height
*/
- void Crop( uint16_t x, uint16_t y, uint16_t width, uint16_t height );
+ void Crop(uint16_t x, uint16_t y, uint16_t width, uint16_t height);
/**
* @brief Resizes the buffer to the given dimensions.
* @param[in] width The new width
* @param[in] height The new height
*/
- void Resize( uint16_t width, uint16_t height );
+ void Resize(uint16_t width, uint16_t height);
/**
* @brief Returns Exif metadata as a property map
* @param[out] metadata Property map object to write into
* @return True on success
*/
- bool GetMetadata( Property::Map& metadata ) const;
+ bool GetMetadata(Property::Map& metadata) const;
/**
* @brief Multiplies the image's color values by the alpha value. This provides better
*
* @return @e false if the rotation fails (invalid pixel format or memory issues).
*/
- bool Rotate( Degree angle );
+ bool Rotate(Degree angle);
/**
* @brief Returns pixel-buffer is premultiplied or not.
bool IsAlphaPreMultiplied() const;
public:
-
/**
* @brief The constructor.
* @note Not intended for application developers.
* @SINCE_1_2.46
* @param[in] pointer A pointer to a newly allocated PixelBuffer
*/
- explicit DALI_INTERNAL PixelBuffer( Internal::Adaptor::PixelBuffer* pointer );
+ explicit DALI_INTERNAL PixelBuffer(Internal::Adaptor::PixelBuffer* pointer);
};
} // namespace Devel
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
SoundPlayer::SoundPlayer()
{
}
return GetImplementation(*this).SoundPlayFinishedSignal();
}
-SoundPlayer::SoundPlayer( Internal::Adaptor::SoundPlayer* player )
-: BaseHandle( player )
+SoundPlayer::SoundPlayer(Internal::Adaptor::SoundPlayer* player)
+: BaseHandle(player)
{
}
#define DALI_SOUND_PLAYER_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Internal DALI_INTERNAL
{
namespace Adaptor
{
class SoundPlayer;
}
-}
+} // namespace DALI_INTERNAL
/**
* @brief Plays sound effects.
class DALI_ADAPTOR_API SoundPlayer : public BaseHandle
{
public:
-
- typedef Signal< void (SoundPlayer&) > SoundPlayFinishedSignalType; ///< Sound play finished signal
+ typedef Signal<void(SoundPlayer&)> SoundPlayFinishedSignalType; ///< Sound play finished signal
/**
* @brief Create an uninitialized handle.
SoundPlayFinishedSignalType& SoundPlayFinishedSignal();
public: // Not intended for application developers
-
/**
* @brief This constructor is used by SoundPlayer::Get().
*
* @param[in] soundPlayer A pointer to the sound player.
*/
- explicit DALI_INTERNAL SoundPlayer( Internal::Adaptor::SoundPlayer* soundPlayer );
+ explicit DALI_INTERNAL SoundPlayer(Internal::Adaptor::SoundPlayer* soundPlayer);
};
} // namespace Dali
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
StyleMonitor::StyleMonitor()
{
}
{
}
-StyleMonitor StyleMonitor::DownCast( BaseHandle handle )
+StyleMonitor StyleMonitor::DownCast(BaseHandle handle)
{
- return StyleMonitor( dynamic_cast<Internal::Adaptor::StyleMonitor*>( handle.GetObjectPtr() ) );
+ return StyleMonitor(dynamic_cast<Internal::Adaptor::StyleMonitor*>(handle.GetObjectPtr()));
}
std::string StyleMonitor::GetDefaultFontFamily() const
return GetImplementation(*this).SetTheme(themFilePath);
}
-bool StyleMonitor::LoadThemeFile( const std::string& filename, std::string& output )
+bool StyleMonitor::LoadThemeFile(const std::string& filename, std::string& output)
{
- return GetImplementation(*this).LoadThemeFile( filename, output );
+ return GetImplementation(*this).LoadThemeFile(filename, output);
}
StyleMonitor::StyleChangeSignalType& StyleMonitor::StyleChangeSignal()
StyleMonitor& StyleMonitor::operator=(const StyleMonitor& monitor)
{
- if( *this != monitor )
+ if(*this != monitor)
{
BaseHandle::operator=(monitor);
}
#define DALI_STYLE_MONITOR_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Internal DALI_INTERNAL
{
namespace Adaptor
{
class StyleMonitor;
}
-}
+} // namespace DALI_INTERNAL
/**
* @brief Monitors the platform for style changes.
*/
class DALI_ADAPTOR_API StyleMonitor : public BaseHandle
{
-public: // Typedefs
-
- typedef Signal< void ( StyleMonitor, StyleChange::Type ) > StyleChangeSignalType; ///< StyleChange Signal type
+public: // Typedefs
+ typedef Signal<void(StyleMonitor, StyleChange::Type)> StyleChangeSignalType; ///< StyleChange Signal type
public: // Creation & Destruction
-
/**
* @brief Create an uninitialized StyleMonitor handle.
*
* @param[in] handle to An object @return handle to a Timer object
* or an uninitialized handle
*/
- static StyleMonitor DownCast( BaseHandle handle );
+ static StyleMonitor DownCast(BaseHandle handle);
public: // Style Information
-
/**
* @brief Retrieves the default font family.
* @return The default font family.
* @param output to write the contents to
* @return true if the load is successful
*/
- bool LoadThemeFile( const std::string& filename, std::string& output );
+ bool LoadThemeFile(const std::string& filename, std::string& output);
public: // Signals
-
/**
* @brief This signal is emitted whenever the style changes on the device.
*
StyleChangeSignalType& StyleChangeSignal();
public: // Operators
-
/**
* @brief Assignment operator.
*
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
{
void SetThreadName(const std::string& threadName)
{
- Internal::Adaptor::ThreadSettings::SetThreadName( threadName );
+ Internal::Adaptor::ThreadSettings::SetThreadName(threadName);
}
} // namespace Dali
#define DALI_THREAD_SETTINGS_H
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
DALI_ADAPTOR_API void SetThreadName(const std::string& threadName);
-} // Dali
+} // namespace Dali
#endif // DALI_THREAD_SETTINGS_H
\ No newline at end of file
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
#include <dali/devel-api/adaptor-framework/tilt-sensor.h>
// INTERNAL INCLUDES
+#include <dali/internal/adaptor/common/adaptor-impl.h>
#include <dali/internal/sensor/common/tilt-sensor-factory.h>
#include <dali/internal/sensor/common/tilt-sensor-impl.h>
-#include <dali/internal/adaptor/common/adaptor-impl.h>
namespace Dali
{
-
const float TiltSensor::DEFAULT_UPDATE_FREQUENCY = 60.0f;
TiltSensor::TiltSensor()
return GetImplementation(*this).TiltedSignal();
}
-void TiltSensor::SetUpdateFrequency( float frequencyHertz )
+void TiltSensor::SetUpdateFrequency(float frequencyHertz)
{
- GetImplementation(*this).SetUpdateFrequency( frequencyHertz );
+ GetImplementation(*this).SetUpdateFrequency(frequencyHertz);
}
float TiltSensor::GetUpdateFrequency() const
void TiltSensor::SetRotationThreshold(Radian rotationThreshold)
{
- GetImplementation(*this).SetRotationThreshold( rotationThreshold );
+ GetImplementation(*this).SetRotationThreshold(rotationThreshold);
}
Radian TiltSensor::GetRotationThreshold() const
return GetImplementation(*this).GetRotationThreshold();
}
-TiltSensor::TiltSensor( Internal::Adaptor::TiltSensor* sensor )
-: BaseHandle( sensor )
+TiltSensor::TiltSensor(Internal::Adaptor::TiltSensor* sensor)
+: BaseHandle(sensor)
{
}
#define DALI_TILT_SENSOR_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Internal DALI_INTERNAL
{
namespace Adaptor
{
class TiltSensor;
}
-}
+} // namespace DALI_INTERNAL
/**
* TiltSensor provides pitch & roll values when the device is tilted.
class DALI_ADAPTOR_API TiltSensor : public BaseHandle
{
public:
-
- typedef Signal< void (const TiltSensor&) > TiltedSignalType;
+ typedef Signal<void(const TiltSensor&)> TiltedSignalType;
static const float DEFAULT_UPDATE_FREQUENCY; // 60 hertz
* The default is TiltSensor::DEFAULT_UPDATE_FREQUENCY.
* @param[in] frequencyHertz The frequency in hertz.
*/
- void SetUpdateFrequency( float frequencyHertz );
+ void SetUpdateFrequency(float frequencyHertz);
/**
* Query the sensor update frequency.
* Example tiltSensor.SetRotationThreshold( Radian(Degree(10) ) // A rotation threshold of 10 degrees
* @param[in] rotationThreshold The threshold value for rotation.
*/
- void SetRotationThreshold( Radian rotationThreshold );
+ void SetRotationThreshold(Radian rotationThreshold);
/**
* Query the rotation threshold above which TiltedSignal will be emitted.
Radian GetRotationThreshold() const;
public: // Not intended for application developers
-
/**
* This constructor is used by TiltSensor::Get().
* @param[in] sensor A pointer to the tilt sensor.
*/
- explicit DALI_INTERNAL TiltSensor( Internal::Adaptor::TiltSensor* sensor );
+ explicit DALI_INTERNAL TiltSensor(Internal::Adaptor::TiltSensor* sensor);
};
} // namespace Dali
#define DALI_VECTOR_ANIMATION_RENDERER_PLUGIN_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
/**
* VectorAnimationRendererPlugin is an abstract interface, used by dali-adaptor to render a vector animation.
* A concrete implementation must be created for each platform and provided as a dynamic library which
class VectorAnimationRendererPlugin
{
public:
-
using UploadCompletedSignalType = Dali::VectorAnimationRenderer::UploadCompletedSignalType;
/**
* @brief Constructor
*/
- VectorAnimationRendererPlugin() {}
+ VectorAnimationRendererPlugin()
+ {
+ }
/**
* @brief Destructor
*/
- virtual ~VectorAnimationRendererPlugin() {}
+ virtual ~VectorAnimationRendererPlugin()
+ {
+ }
/**
* @brief Second-phase constructor.
*
* @param[in] url The url of the animation file
*/
- virtual bool Initialize( const std::string& url ) = 0;
+ virtual bool Initialize(const std::string& url) = 0;
/**
* @brief Finalizes the renderer. It will be called in the main thread.
*
* @param[in] renderer The renderer used to display the result image
*/
- virtual void SetRenderer( Renderer renderer ) = 0;
+ virtual void SetRenderer(Renderer renderer) = 0;
/**
* @brief Sets the target image size.
* @param[in] width The target image width
* @param[in] height The target image height
*/
- virtual void SetSize( uint32_t width, uint32_t height ) = 0;
+ virtual void SetSize(uint32_t width, uint32_t height) = 0;
/**
* @brief Renders the content to the target buffer synchronously.
* @param[in] frameNumber The frame number to be rendered
* @return True if the rendering success, false otherwise.
*/
- virtual bool Render( uint32_t frameNumber ) = 0;
+ virtual bool Render(uint32_t frameNumber) = 0;
/**
* @brief Gets the total number of frames of the file.
* @param[out] width The default width of the file
* @param[out] height The default height of the file
*/
- virtual void GetDefaultSize( uint32_t& width, uint32_t& height ) const = 0;
+ virtual void GetDefaultSize(uint32_t& width, uint32_t& height) const = 0;
/**
* @brief Gets the layer information of all the child layers.
*
* @param[out] map The layer information
*/
- virtual void GetLayerInfo( Property::Map& map ) const = 0;
+ virtual void GetLayerInfo(Property::Map& map) const = 0;
/**
* @brief Gets the start frame and the end frame number of the composition marker.
* Marker can be use to devide a resource in to separate animations by tagging the segment with comment string,
* start frame and duration of that segment.
*/
- virtual bool GetMarkerInfo( const std::string& marker, uint32_t& startFrame, uint32_t& endFrame ) const = 0;
+ virtual bool GetMarkerInfo(const std::string& marker, uint32_t& startFrame, uint32_t& endFrame) const = 0;
/**
* @brief Ignores a rendered frame which is not shown yet.
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
-VectorAnimationRenderer VectorAnimationRenderer::New( const std::string& url )
+VectorAnimationRenderer VectorAnimationRenderer::New(const std::string& url)
{
Internal::Adaptor::VectorAnimationRendererPtr animationRenderer = Internal::Adaptor::VectorAnimationRenderer::New();
- if( animationRenderer )
+ if(animationRenderer)
{
- animationRenderer->Initialize( url );
+ animationRenderer->Initialize(url);
}
- return VectorAnimationRenderer( animationRenderer.Get() );
+ return VectorAnimationRenderer(animationRenderer.Get());
}
VectorAnimationRenderer::VectorAnimationRenderer()
{
}
-VectorAnimationRenderer::VectorAnimationRenderer( Internal::Adaptor::VectorAnimationRenderer* internal )
-: BaseHandle( internal )
+VectorAnimationRenderer::VectorAnimationRenderer(Internal::Adaptor::VectorAnimationRenderer* internal)
+: BaseHandle(internal)
{
}
-VectorAnimationRenderer::VectorAnimationRenderer( const VectorAnimationRenderer& handle )
-: BaseHandle( handle )
+VectorAnimationRenderer::VectorAnimationRenderer(const VectorAnimationRenderer& handle)
+: BaseHandle(handle)
{
}
-VectorAnimationRenderer& VectorAnimationRenderer::operator=( const VectorAnimationRenderer& rhs )
+VectorAnimationRenderer& VectorAnimationRenderer::operator=(const VectorAnimationRenderer& rhs)
{
- BaseHandle::operator=( rhs );
+ BaseHandle::operator=(rhs);
return *this;
}
void VectorAnimationRenderer::Finalize()
{
- GetImplementation( *this ).Finalize();
+ GetImplementation(*this).Finalize();
}
-void VectorAnimationRenderer::SetRenderer( Renderer renderer )
+void VectorAnimationRenderer::SetRenderer(Renderer renderer)
{
- GetImplementation( *this ).SetRenderer( renderer );
+ GetImplementation(*this).SetRenderer(renderer);
}
-void VectorAnimationRenderer::SetSize( uint32_t width, uint32_t height )
+void VectorAnimationRenderer::SetSize(uint32_t width, uint32_t height)
{
- GetImplementation( *this ).SetSize( width, height );
+ GetImplementation(*this).SetSize(width, height);
}
-bool VectorAnimationRenderer::Render( uint32_t frameNumber )
+bool VectorAnimationRenderer::Render(uint32_t frameNumber)
{
- return GetImplementation( *this ).Render( frameNumber );
+ return GetImplementation(*this).Render(frameNumber);
}
uint32_t VectorAnimationRenderer::GetTotalFrameNumber() const
{
- return GetImplementation( *this ).GetTotalFrameNumber();
+ return GetImplementation(*this).GetTotalFrameNumber();
}
float VectorAnimationRenderer::GetFrameRate() const
{
- return GetImplementation( *this ).GetFrameRate();
+ return GetImplementation(*this).GetFrameRate();
}
-void VectorAnimationRenderer::GetDefaultSize( uint32_t& width, uint32_t& height ) const
+void VectorAnimationRenderer::GetDefaultSize(uint32_t& width, uint32_t& height) const
{
- GetImplementation( *this ).GetDefaultSize( width, height );
+ GetImplementation(*this).GetDefaultSize(width, height);
}
-void VectorAnimationRenderer::GetLayerInfo( Property::Map& map ) const
+void VectorAnimationRenderer::GetLayerInfo(Property::Map& map) const
{
- GetImplementation( *this ).GetLayerInfo( map );
+ GetImplementation(*this).GetLayerInfo(map);
}
-bool VectorAnimationRenderer::GetMarkerInfo( const std::string& marker, uint32_t& startFrame, uint32_t& endFrame ) const
+bool VectorAnimationRenderer::GetMarkerInfo(const std::string& marker, uint32_t& startFrame, uint32_t& endFrame) const
{
- return GetImplementation( *this ).GetMarkerInfo( marker, startFrame, endFrame );
+ return GetImplementation(*this).GetMarkerInfo(marker, startFrame, endFrame);
}
void VectorAnimationRenderer::IgnoreRenderedFrame()
{
- GetImplementation( *this ).IgnoreRenderedFrame();
+ GetImplementation(*this).IgnoreRenderedFrame();
}
VectorAnimationRenderer::UploadCompletedSignalType& VectorAnimationRenderer::UploadCompletedSignal()
{
- return GetImplementation( *this ).UploadCompletedSignal();
+ return GetImplementation(*this).UploadCompletedSignal();
}
} // namespace Dali
#define DALI_VECTOR_ANIMATION_RENDERER_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
{
class VectorAnimationRenderer;
}
-}
+} // namespace DALI_INTERNAL
/**
* @brief Used for rendering a vector animation file
class DALI_ADAPTOR_API VectorAnimationRenderer : public BaseHandle
{
public:
-
/// @brief UploadCompleted signal type.
- using UploadCompletedSignalType = Signal< void () >;
+ using UploadCompletedSignalType = Signal<void()>;
/**
* @brief Creates an initialized handle to a new VectorAnimationRenderer.
* @param[in] url The url of the vector animation file
* @return A handle to a newly allocated VectorAnimationRenderer
*/
- static VectorAnimationRenderer New( const std::string& url );
+ static VectorAnimationRenderer New(const std::string& url);
/**
* @brief Creates an empty handle.
*
* @param[in] handle A reference to the copied handle
*/
- VectorAnimationRenderer( const VectorAnimationRenderer& handle );
+ VectorAnimationRenderer(const VectorAnimationRenderer& handle);
/**
* @brief This assignment operator is required for (smart) pointer semantics.
* @param[in] rhs A reference to the copied handle
* @return A reference to this
*/
- VectorAnimationRenderer& operator=( const VectorAnimationRenderer& rhs );
+ VectorAnimationRenderer& operator=(const VectorAnimationRenderer& rhs);
/**
* @brief Finalizes the renderer.
*
* @param[in] renderer The renderer used to display the result image
*/
- void SetRenderer( Renderer renderer );
+ void SetRenderer(Renderer renderer);
/**
* @brief Sets the target image size.
* @param[in] width The target image width
* @param[in] height The target image height
*/
- void SetSize( uint32_t width, uint32_t height );
+ void SetSize(uint32_t width, uint32_t height);
/**
* @brief Renders the content to the target buffer synchronously.
* @param[in] frameNumber The frame number to be rendered
* @return True if the rendering success, false otherwise.
*/
- bool Render( uint32_t frameNumber );
+ bool Render(uint32_t frameNumber);
/**
* @brief Gets the total number of frames of the file
* @param[out] width The default width of the file
* @param[out] height The default height of the file
*/
- void GetDefaultSize( uint32_t& width, uint32_t& height ) const;
+ void GetDefaultSize(uint32_t& width, uint32_t& height) const;
/**
* @brief Gets the layer information of all the child layers.
*
* @param[out] map The layer information
*/
- void GetLayerInfo( Property::Map& map ) const;
+ void GetLayerInfo(Property::Map& map) const;
/**
* @brief Gets the start frame and the end frame number of the composition marker.
* Marker can be use to devide a resource in to separate animations by tagging the segment with comment string,
* start frame and duration of that segment.
*/
- bool GetMarkerInfo( const std::string& marker, uint32_t& startFrame, uint32_t& endFrame ) const;
+ bool GetMarkerInfo(const std::string& marker, uint32_t& startFrame, uint32_t& endFrame) const;
/**
* @brief Ignores a rendered frame which is not shown yet.
void IgnoreRenderedFrame();
public: // Signals
-
/**
* @brief Connect to this signal to be notified when the texture upload is completed.
*
UploadCompletedSignalType& UploadCompletedSignal();
public: // Not intended for application developers
-
/// @cond internal
/**
* @brief The constructor.
*
* @param[in] pointer A pointer to a newly allocated VectorAnimationRenderer
*/
- explicit DALI_INTERNAL VectorAnimationRenderer( Internal::Adaptor::VectorAnimationRenderer* internal );
+ explicit DALI_INTERNAL VectorAnimationRenderer(Internal::Adaptor::VectorAnimationRenderer* internal);
/// @endcond
-
};
/**
#define DALI_VIDEO_PLAYER_PLUGIN_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
// EXTERNAL INCLUDES
-#include <dali/public-api/signals/dali-signal.h>
-#include <dali/public-api/math/rect.h>
#include <dali/public-api/actors/actor.h>
+#include <dali/public-api/math/rect.h>
+#include <dali/public-api/signals/dali-signal.h>
namespace Dali
{
-
class Any;
-typedef Dali::Rect< int > DisplayArea;
+typedef Dali::Rect<int> DisplayArea;
/**
* @brief VideoPlayerPlugin is an abstract interface, used by dali-adaptor to access video player plugin.
class VideoPlayerPlugin
{
public:
-
- typedef Signal< void () > VideoPlayerSignalType;
+ typedef Signal<void()> VideoPlayerSignalType;
/**
* @brief Video display rotation option
*/
enum DisplayRotation
{
- ROTATION_NONE, ///< Display isn't rotated. @SINCE_1_1.38
- ROTATION_90, ///< Display is rotated 90 degree. @SINCE_1_1.38
- ROTATION_180, ///< Display is rotated 180 degree. @SINCE_1_1.38
- ROTATION_270 ///< Display is rotated 270 degree. @SINCE_1_1.38
+ ROTATION_NONE, ///< Display isn't rotated. @SINCE_1_1.38
+ ROTATION_90, ///< Display is rotated 90 degree. @SINCE_1_1.38
+ ROTATION_180, ///< Display is rotated 180 degree. @SINCE_1_1.38
+ ROTATION_270 ///< Display is rotated 270 degree. @SINCE_1_1.38
};
/**
*/
enum class CodecType
{
- DEFAULT, ///< Codec which has higher priority as default. Platform selects it. Usually the H/W codec has higher priority than S/W codec if it exist.
- HW, ///< H/W codec
- SW ///< S/W codec
+ DEFAULT, ///< Codec which has higher priority as default. Platform selects it. Usually the H/W codec has higher priority than S/W codec if it exist.
+ HW, ///< H/W codec
+ SW ///< S/W codec
};
/**
{
enum Type
{
- LETTER_BOX = 0, /**< Letter box */
- ORIGIN_SIZE, /**< Origin size */
- FULL_SCREEN, /**< Full-screen */
- CROPPED_FULL, /**< Cropped full-screen */
- ORIGIN_OR_LETTER, /**< Origin size (if surface size is larger than video size(width/height)) or Letter box (if video size(width/height) is larger than surface size) */
- DST_ROI /**< Region of Interest */
+ LETTER_BOX = 0, /**< Letter box */
+ ORIGIN_SIZE, /**< Origin size */
+ FULL_SCREEN, /**< Full-screen */
+ CROPPED_FULL, /**< Cropped full-screen */
+ ORIGIN_OR_LETTER, /**< Origin size (if surface size is larger than video size(width/height)) or Letter box (if video size(width/height) is larger than surface size) */
+ DST_ROI /**< Region of Interest */
};
};
* @brief Constructor.
* @SINCE_1_1.38
*/
- VideoPlayerPlugin(){}
+ VideoPlayerPlugin()
+ {
+ }
/**
* @brief Destructor.
* @SINCE_1_1.38
*/
- virtual ~VideoPlayerPlugin(){}
+ virtual ~VideoPlayerPlugin()
+ {
+ }
/**
* @brief Sets a URL of the video file to play.
* @SINCE_1_1.38
* @param [in] url The url of video file
*/
- virtual void SetUrl( const std::string& url ) = 0;
+ virtual void SetUrl(const std::string& url) = 0;
/**
* @brief Returns the URL of the video file.
* @SINCE_1_1.38
* @param[in] mute The new mute status, true is mute.
*/
- virtual void SetMute( bool mute ) = 0;
+ virtual void SetMute(bool mute) = 0;
/**
* @brief Returns the player mute status.
* @param[in] left The left volume scalar
* @param[in] right The right volume scalar
*/
- virtual void SetVolume( float left, float right ) = 0;
+ virtual void SetVolume(float left, float right) = 0;
/**
* @brief Gets current volume factor.
* @param[out] left The current left volume scalar
* @param[out] right The current right volume scalar
*/
- virtual void GetVolume( float& left, float& right ) = 0;
+ virtual void GetVolume(float& left, float& right) = 0;
/**
* @brief Sets video rendering target.
* @SINCE_1_1.38
* @param[in] target The target for video rendering, window surface or native image source
*/
- virtual void SetRenderingTarget( Any target ) = 0;
+ virtual void SetRenderingTarget(Any target) = 0;
/**
* @brief Sets the position for playback.
*
* @param[in] millisecond The position for playback
*/
- virtual void SetPlayPosition( int millisecond ) = 0;
+ virtual void SetPlayPosition(int millisecond) = 0;
/**
* @brief Returns the current position in milliseconds.
* @SINCE_1_2.46
* param[in] area The left-top position and size of the video display area
*/
- virtual void SetDisplayArea( DisplayArea area ) = 0;
+ virtual void SetDisplayArea(DisplayArea area) = 0;
/**
* @brief Sets video display rotation
* @SINCE_1_1.38
* @param[in] rotation The rotation of display
*/
- virtual void SetDisplayRotation( Dali::VideoPlayerPlugin::DisplayRotation rotation ) = 0;
+ virtual void SetDisplayRotation(Dali::VideoPlayerPlugin::DisplayRotation rotation) = 0;
/**
* @brief Returns rotation of current video display
* @SINCE_1_2.46
* @param[in] millisecond The position for forward playback
*/
- virtual void Forward( int millisecond ) = 0;
+ virtual void Forward(int millisecond) = 0;
/**
* @brief Seeks backward by the specified number of milliseconds.
* @SINCE_1_2.46
* @param[in] millisecond The position for backward playback
*/
- virtual void Backward( int millisecond ) = 0;
+ virtual void Backward(int millisecond) = 0;
/**
* @brief Checks whether the video texture is supported
* @brief Sets codec type
* @param[in] type The CodecType
*/
- virtual void SetCodecType( VideoPlayerPlugin::CodecType type ) = 0;
+ virtual void SetCodecType(VideoPlayerPlugin::CodecType type) = 0;
/**
* @brief Gets codec type
* @brief Sets the display mode for playback.
* @param[in] mode of playback
*/
- virtual void SetDisplayMode( VideoPlayerPlugin::DisplayMode::Type mode ) = 0;
+ virtual void SetDisplayMode(VideoPlayerPlugin::DisplayMode::Type mode) = 0;
/**
* @brief Returns the current display mode.
* This function is called, the synchronization is finished between UI(transparent hole) and video player.
*/
virtual void FinishSynchronization() = 0;
-
};
-} // namespace Dali;
+} // namespace Dali
#endif // DALI_VIDEO_PLAYER_PLUGIN_H
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
VideoPlayer::VideoPlayer()
{
}
-VideoPlayer::VideoPlayer( Internal::Adaptor::VideoPlayer* internal )
-: BaseHandle( internal )
+VideoPlayer::VideoPlayer(Internal::Adaptor::VideoPlayer* internal)
+: BaseHandle(internal)
{
}
{
Internal::Adaptor::VideoPlayerPtr player = Internal::Adaptor::VideoPlayer::New();
- if( player )
+ if(player)
{
Dali::Actor actor;
- player->Initialize( actor, VideoSyncMode::DISABLED );
+ player->Initialize(actor, VideoSyncMode::DISABLED);
}
- return VideoPlayer( player.Get() );
+ return VideoPlayer(player.Get());
}
-VideoPlayer VideoPlayer::New( Dali::Actor actor, VideoSyncMode syncMode )
+VideoPlayer VideoPlayer::New(Dali::Actor actor, VideoSyncMode syncMode)
{
Internal::Adaptor::VideoPlayerPtr player = Internal::Adaptor::VideoPlayer::New();
- if( player )
+ if(player)
{
- player->Initialize( actor, syncMode );
+ player->Initialize(actor, syncMode);
}
- return VideoPlayer( player.Get() );
+ return VideoPlayer(player.Get());
}
-VideoPlayer::VideoPlayer( const VideoPlayer& player )
-: BaseHandle( player )
+VideoPlayer::VideoPlayer(const VideoPlayer& player)
+: BaseHandle(player)
{
}
-VideoPlayer& VideoPlayer::operator=( const VideoPlayer& player )
+VideoPlayer& VideoPlayer::operator=(const VideoPlayer& player)
{
- if( *this != player )
+ if(*this != player)
{
- BaseHandle::operator=( player );
+ BaseHandle::operator=(player);
}
return *this;
}
-VideoPlayer VideoPlayer::DownCast( BaseHandle handle )
+VideoPlayer VideoPlayer::DownCast(BaseHandle handle)
{
- return VideoPlayer( dynamic_cast< Internal::Adaptor::VideoPlayer* >( handle.GetObjectPtr() ) );
+ return VideoPlayer(dynamic_cast<Internal::Adaptor::VideoPlayer*>(handle.GetObjectPtr()));
}
-void VideoPlayer::SetUrl( const std::string& url )
+void VideoPlayer::SetUrl(const std::string& url)
{
- GetImplementation( *this ).SetUrl( url );
+ GetImplementation(*this).SetUrl(url);
}
std::string VideoPlayer::GetUrl()
{
- return GetImplementation( *this ).GetUrl();
+ return GetImplementation(*this).GetUrl();
}
void VideoPlayer::SetLooping(bool looping)
{
- GetImplementation( *this ).SetLooping( looping );
+ GetImplementation(*this).SetLooping(looping);
}
bool VideoPlayer::IsLooping()
{
- return GetImplementation( *this ).IsLooping();
+ return GetImplementation(*this).IsLooping();
}
void VideoPlayer::Play()
{
- GetImplementation( *this ).Play();
+ GetImplementation(*this).Play();
}
void VideoPlayer::Pause()
{
- GetImplementation( *this ).Pause();
+ GetImplementation(*this).Pause();
}
void VideoPlayer::Stop()
{
- GetImplementation( *this ).Stop();
+ GetImplementation(*this).Stop();
}
-void VideoPlayer::SetMute( bool mute )
+void VideoPlayer::SetMute(bool mute)
{
- GetImplementation( *this ).SetMute( mute );
+ GetImplementation(*this).SetMute(mute);
}
bool VideoPlayer::IsMuted()
{
- return GetImplementation( *this ).IsMuted();
+ return GetImplementation(*this).IsMuted();
}
-void VideoPlayer::SetVolume( float left, float right )
+void VideoPlayer::SetVolume(float left, float right)
{
- GetImplementation( *this ).SetVolume( left, right );
+ GetImplementation(*this).SetVolume(left, right);
}
-void VideoPlayer::GetVolume( float& left, float& right )
+void VideoPlayer::GetVolume(float& left, float& right)
{
- GetImplementation( *this ).GetVolume( left, right );
+ GetImplementation(*this).GetVolume(left, right);
}
-void VideoPlayer::SetRenderingTarget( Any target )
+void VideoPlayer::SetRenderingTarget(Any target)
{
- GetImplementation( *this ).SetRenderingTarget( target );
+ GetImplementation(*this).SetRenderingTarget(target);
}
-void VideoPlayer::SetPlayPosition( int millisecond )
+void VideoPlayer::SetPlayPosition(int millisecond)
{
- GetImplementation( *this ).SetPlayPosition( millisecond );
+ GetImplementation(*this).SetPlayPosition(millisecond);
}
int VideoPlayer::GetPlayPosition()
{
- return GetImplementation( *this ).GetPlayPosition();
+ return GetImplementation(*this).GetPlayPosition();
}
-void VideoPlayer::SetDisplayArea( DisplayArea area )
+void VideoPlayer::SetDisplayArea(DisplayArea area)
{
- GetImplementation( *this ).SetDisplayArea( area );
+ GetImplementation(*this).SetDisplayArea(area);
}
-void VideoPlayer::SetDisplayRotation( Dali::VideoPlayerPlugin::DisplayRotation rotation )
+void VideoPlayer::SetDisplayRotation(Dali::VideoPlayerPlugin::DisplayRotation rotation)
{
- GetImplementation( *this ).SetDisplayRotation( rotation );
+ GetImplementation(*this).SetDisplayRotation(rotation);
}
Dali::VideoPlayerPlugin::DisplayRotation VideoPlayer::GetDisplayRotation()
{
- return GetImplementation( *this ).GetDisplayRotation();
+ return GetImplementation(*this).GetDisplayRotation();
}
Dali::VideoPlayerPlugin::VideoPlayerSignalType& VideoPlayer::FinishedSignal()
{
- return GetImplementation( *this ).FinishedSignal();
+ return GetImplementation(*this).FinishedSignal();
}
-void VideoPlayer::Forward( int millisecond )
+void VideoPlayer::Forward(int millisecond)
{
- GetImplementation( *this ).Forward( millisecond );
+ GetImplementation(*this).Forward(millisecond);
}
-void VideoPlayer::Backward( int millisecond )
+void VideoPlayer::Backward(int millisecond)
{
- GetImplementation( *this ).Backward( millisecond );
+ GetImplementation(*this).Backward(millisecond);
}
bool VideoPlayer::IsVideoTextureSupported()
{
- return GetImplementation( *this ).IsVideoTextureSupported();
+ return GetImplementation(*this).IsVideoTextureSupported();
}
-void VideoPlayer::SetCodecType( Dali::VideoPlayerPlugin::CodecType type )
+void VideoPlayer::SetCodecType(Dali::VideoPlayerPlugin::CodecType type)
{
- GetImplementation( *this ).SetCodecType( type );
+ GetImplementation(*this).SetCodecType(type);
}
Dali::VideoPlayerPlugin::CodecType VideoPlayer::GetCodecType() const
{
- return GetImplementation( *this ).GetCodecType();
+ return GetImplementation(*this).GetCodecType();
}
-void VideoPlayer::SetDisplayMode( Dali::VideoPlayerPlugin::DisplayMode::Type mode )
+void VideoPlayer::SetDisplayMode(Dali::VideoPlayerPlugin::DisplayMode::Type mode)
{
- GetImplementation( *this ).SetDisplayMode( mode );
+ GetImplementation(*this).SetDisplayMode(mode);
}
Dali::VideoPlayerPlugin::DisplayMode::Type VideoPlayer::GetDisplayMode() const
{
- return GetImplementation( *this ).GetDisplayMode();
+ return GetImplementation(*this).GetDisplayMode();
}
Any VideoPlayer::GetMediaPlayer()
{
- return GetImplementation( *this ).GetMediaPlayer();
+ return GetImplementation(*this).GetMediaPlayer();
}
void VideoPlayer::StartSynchronization()
{
- GetImplementation( *this ).StartSynchronization();
+ GetImplementation(*this).StartSynchronization();
}
void VideoPlayer::FinishSynchronization()
{
- GetImplementation( *this ).FinishSynchronization();
+ GetImplementation(*this).FinishSynchronization();
}
-} // namespace Dali;
-
+} // namespace Dali
#define DALI_VIDEO_PLAYER_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
// EXTERNAL INCLUDES
-#include <dali/public-api/object/base-handle.h>
#include <dali/devel-api/adaptor-framework/video-sync-mode.h>
+#include <dali/public-api/object/base-handle.h>
//INTERNAL INCLUDES
#include <dali/devel-api/adaptor-framework/video-player-plugin.h>
namespace Dali
{
-
class Any;
namespace Internal
{
-
namespace Adaptor
{
- class VideoPlayer;
+class VideoPlayer;
} // namespace Adaptor
} // namespace Internal
* @brief VideoPlayer class is used for video playback.
* @SINCE_1_1.38
*/
-class DALI_ADAPTOR_API VideoPlayer: public BaseHandle
+class DALI_ADAPTOR_API VideoPlayer : public BaseHandle
{
public:
-
/**
* @brief Constructor.
* @SINCE_1_1.38
* @param[in] actor video view's actor instance
* @param[in] syncMode The synchronization mode between the UI (transparent hole) and VideoPlayer.
*/
- static VideoPlayer New( Dali::Actor actor, VideoSyncMode syncMode );
+ static VideoPlayer New(Dali::Actor actor, VideoSyncMode syncMode);
- /**
+ /**
* @brief Copy constructor.
*
* @SINCE_1_1.38
* @param[in] player VideoPlayer to copy. The copied player will point at the same implementation
*/
- VideoPlayer( const VideoPlayer& player );
+ VideoPlayer(const VideoPlayer& player);
- /**
+ /**
* @brief Assignment operator.
*
* @SINCE_1_1.38
* @param[in] player The VideoPlayer to assign from.
* @return The updated VideoPlayer.
*/
- VideoPlayer& operator=( const VideoPlayer& player );
+ VideoPlayer& operator=(const VideoPlayer& player);
/**
* @brief Downcast a handle to VideoPlayer handle.
* @param[in] handle Handle to an object
* @return Handle to a VideoPlayer or an uninitialized handle
*/
- static VideoPlayer DownCast( BaseHandle handle );
+ static VideoPlayer DownCast(BaseHandle handle);
/**
* @brief Sets a URL of the video file to play.
* @SINCE_1_1.38
* @param [in] url The url of video file
*/
- void SetUrl( const std::string& url );
+ void SetUrl(const std::string& url);
/**
* @brief Returns the URL of the video file.
* @SINCE_1_1.38
* @param[in] mute The new mute status, true is mute.
*/
- void SetMute( bool mute );
+ void SetMute(bool mute);
/**
* @brief Returns the player mute status.
* @param[in] left The left volume scalar
* @param[in] right The right volume scalar
*/
- void SetVolume( float left, float right );
+ void SetVolume(float left, float right);
/**
* @brief Returns current volume factor.
* @param[out] left The current left volume scalar
* @param[out] right The current right volume scalar
*/
- void GetVolume( float& left, float& right );
+ void GetVolume(float& left, float& right);
/**
* @brief Sets video rendering target.
* @SINCE_1_1.38
* @param[in] target The target for video rendering, window surface or native image source
*/
- void SetRenderingTarget( Any target );
+ void SetRenderingTarget(Any target);
/**
* @brief Sets the position for playback.
*
* @param[in] millisecond The position for playback
*/
- void SetPlayPosition( int millisecond );
+ void SetPlayPosition(int millisecond);
/**
* @brief Gets the current position in milliseconds.
* @SINCE_1_2.46
* param[in] area The left-top position and size of the video display area
*/
- void SetDisplayArea( DisplayArea area );
+ void SetDisplayArea(DisplayArea area);
/**
* @brief Sets video display rotation
* @SINCE_1_1.38
* @param[in] rotation The rotation of display
*/
- void SetDisplayRotation( Dali::VideoPlayerPlugin::DisplayRotation rotation );
+ void SetDisplayRotation(Dali::VideoPlayerPlugin::DisplayRotation rotation);
/**
* @brief Returns rotation of current video display
* @SINCE_1_2.46
* @param[in] millisecond The position for forward playback
*/
- void Forward( int millisecond );
+ void Forward(int millisecond);
/**
* @brief Seeks backward by the specified number of milliseconds.
* @SINCE_1_2.46
* @param[in] millisecond The position for backward playback
*/
- void Backward( int millisecond );
+ void Backward(int millisecond);
/**
* @brief Checks whether the video texture is supported
* @brief Sets codec type
* @param[in] type The VideoCodec::Type
*/
- void SetCodecType( Dali::VideoPlayerPlugin::CodecType type );
+ void SetCodecType(Dali::VideoPlayerPlugin::CodecType type);
/**
* @brief Gets codec type
* @brief Sets the display mode for playback.
* @param[in] mode of playback
*/
- void SetDisplayMode( Dali::VideoPlayerPlugin::DisplayMode::Type mode );
+ void SetDisplayMode(Dali::VideoPlayerPlugin::DisplayMode::Type mode);
/**
* @brief Gets display mode
void FinishSynchronization();
private: // Not intended for application developers
-
/**
* @brief Internal constructor
* @SINCE_1_1.38
*/
- explicit DALI_INTERNAL VideoPlayer( Internal::Adaptor::VideoPlayer* internal );
+ explicit DALI_INTERNAL VideoPlayer(Internal::Adaptor::VideoPlayer* internal);
};
-} // namespace Dali;
+} // namespace Dali
#endif // DALI_VIDEO_PLAYER_H
#define DALI_VIDEO_SYNC_MODE
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
- /**
+/**
* @brief Enumeration for the synchronization is ended between UI(transparent hole) and video player.
*/
- enum class VideoSyncMode
- {
- DISABLED = 0,
- ENABLED
- };
+enum class VideoSyncMode
+{
+ DISABLED = 0,
+ ENABLED
+};
-} // Dali
+} // namespace Dali
#endif // DALI_VIDEO_SYNC_MODE
-
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace VirtualKeyboard
{
-
void Show()
{
Internal::Adaptor::VirtualKeyboard::Show();
return Internal::Adaptor::VirtualKeyboard::IsVisible();
}
-void ApplySettings( const Property::Map& settingsMap )
+void ApplySettings(const Property::Map& settingsMap)
{
- Internal::Adaptor::VirtualKeyboard::ApplySettings( settingsMap );
+ Internal::Adaptor::VirtualKeyboard::ApplySettings(settingsMap);
}
-void SetReturnKeyType( const InputMethod::ButtonAction::Type type )
+void SetReturnKeyType(const InputMethod::ButtonAction::Type type)
{
- Internal::Adaptor::VirtualKeyboard::SetReturnKeyType( type );
+ Internal::Adaptor::VirtualKeyboard::SetReturnKeyType(type);
}
InputMethod::ButtonAction::Type GetReturnKeyType()
#define DALI_VIRTUAL_KEYBOARD_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
// EXTERNAL INCLUDES
-#include <dali/public-api/signals/dali-signal.h>
-#include <dali/public-api/object/property-map.h>
#include <dali/public-api/math/rect.h>
+#include <dali/public-api/object/property-map.h>
+#include <dali/public-api/signals/dali-signal.h>
// INTERNAL INCLUDES
#include <dali/public-api/adaptor-framework/input-method.h>
namespace Dali
{
-
/**
* @brief This namespace is provided for application developers to be able to show and hide the on-screen keyboard.
*
*/
namespace VirtualKeyboard
{
-
// Types
-typedef Signal< void () > VoidSignalType;
-typedef Signal< void ( bool ) > StatusSignalType;
-typedef Signal< void ( int ) > KeyboardResizedSignalType;
-typedef Signal< void ( int ) > LanguageChangedSignalType;
+typedef Signal<void()> VoidSignalType;
+typedef Signal<void(bool)> StatusSignalType;
+typedef Signal<void(int)> KeyboardResizedSignalType;
+typedef Signal<void(int)> LanguageChangedSignalType;
// Enumerations
* @brief Set one or more of the Input Method Settings
* @param[in] settingsMap Map of Settings to be applied.
*/
-DALI_ADAPTOR_API void ApplySettings( const Property::Map& settingsMap );
+DALI_ADAPTOR_API void ApplySettings(const Property::Map& settingsMap);
/**
* @brief Set the specific return key into the virtual keyboard.
* @param[in] type the kind of return key types.
*/
-DALI_ADAPTOR_API void SetReturnKeyType( const InputMethod::ButtonAction::Type type );
+DALI_ADAPTOR_API void SetReturnKeyType(const InputMethod::ButtonAction::Type type);
/**
* @brief Retrieve the current return key type.
namespace Dali
{
-
class KeyEvent;
class TouchEvent;
class WebEnginePlugin
{
public:
-
/**
* @brief WebEngine signal type related with page loading.
*/
- typedef Signal< void( const std::string& ) > WebEnginePageLoadSignalType;
+ typedef Signal<void(const std::string&)> WebEnginePageLoadSignalType;
/**
* @brief WebView signal type related with page loading error.
*/
- typedef Signal< void( const std::string&, int ) > WebEnginePageLoadErrorSignalType;
+ typedef Signal<void(const std::string&, int)> WebEnginePageLoadErrorSignalType;
/**
* @brief Enumeration for cache model options.
* @param [in] locale The locale of Web
* @param [in] timezoneId The timezoneID of Web
*/
- virtual void Create( int width, int height, const std::string& locale, const std::string& timezoneId ) = 0;
+ virtual void Create(int width, int height, const std::string& locale, const std::string& timezoneId) = 0;
/**
* @brief Destroys WebEngine instance.
*
* @param [in] url The URL of the resource to load
*/
- virtual void LoadUrl( const std::string& url ) = 0;
+ virtual void LoadUrl(const std::string& url) = 0;
/**
* @brief Gets image to render.
*
* @param [in] htmlString The string to use as the contents of the web page
*/
- virtual void LoadHTMLString( const std::string& htmlString ) = 0;
+ virtual void LoadHTMLString(const std::string& htmlString) = 0;
/**
* @brief Reloads the Web.
* @param[in] script The JavaScript code
* @param[in] resultHandler The callback function to be called by the JavaScript runtime. This carries evaluation result.
*/
- virtual void EvaluateJavaScript( const std::string& script, std::function< void( const std::string& ) > resultHandler ) = 0;
+ virtual void EvaluateJavaScript(const std::string& script, std::function<void(const std::string&)> resultHandler) = 0;
/**
* @brief Add a message handler into JavaScript.
* @param[in] exposedObjectName The name of exposed object
* @param[in] handler The callback function
*/
- virtual void AddJavaScriptMessageHandler( const std::string& exposedObjectName, std::function< void( const std::string& ) > handler ) = 0;
+ virtual void AddJavaScriptMessageHandler(const std::string& exposedObjectName, std::function<void(const std::string&)> handler) = 0;
/**
* @brief Clears the history of Web.
*
* @param[in] cacheModel The cache model option
*/
- virtual void SetCacheModel( CacheModel cacheModel ) = 0;
+ virtual void SetCacheModel(CacheModel cacheModel) = 0;
/**
* @brief Gets the cookie acceptance policy. The default is NO_THIRD_PARTY.
*
* @param[in] policy The cookie acceptance policy
*/
- virtual void SetCookieAcceptPolicy( CookieAcceptPolicy policy ) = 0;
+ virtual void SetCookieAcceptPolicy(CookieAcceptPolicy policy) = 0;
/**
* @brief Get user agent string.
*
* @param[in] userAgent The string value of user agent
*/
- virtual void SetUserAgent( const std::string& userAgent ) = 0;
+ virtual void SetUserAgent(const std::string& userAgent) = 0;
/**
* @brief Returns whether JavaScript can be executable. The default is true.
*
* @param[in] enabled True if JavaScript executing is enabled, false otherwise
*/
- virtual void EnableJavaScript( bool enabled ) = 0;
+ virtual void EnableJavaScript(bool enabled) = 0;
/**
* @brief Returns whether images can be loaded automatically. The default is true.
*
* @param[in] automatic True if images are loaded automatically, false otherwise
*/
- virtual void LoadImagesAutomatically( bool automatic ) = 0;
+ virtual void LoadImagesAutomatically(bool automatic) = 0;
/**
* @brief Gets the default text encoding name (e.g. UTF-8).
*
* @param[in] defaultTextEncodingName The default text encoding name
*/
- virtual void SetDefaultTextEncodingName( const std::string& defaultTextEncodingName ) = 0;
+ virtual void SetDefaultTextEncodingName(const std::string& defaultTextEncodingName) = 0;
/**
* @brief Returns the default font size in pixel. The default value is 16.
*
* @param[in] defaultFontSize A new default font size to set
*/
- virtual void SetDefaultFontSize( int defaultFontSize ) = 0;
+ virtual void SetDefaultFontSize(int defaultFontSize) = 0;
/**
* @brief Sets size of Web Page.
*/
- virtual void SetSize( int width, int height ) = 0;
+ virtual void SetSize(int width, int height) = 0;
/**
* @brief Sends Touch Events.
*/
- virtual bool SendTouchEvent( const TouchEvent& touch ) = 0;
+ virtual bool SendTouchEvent(const TouchEvent& touch) = 0;
/**
* @brief Sends Key Events.
*/
- virtual bool SendKeyEvent( const KeyEvent& event ) = 0;
+ virtual bool SendKeyEvent(const KeyEvent& event) = 0;
/**
* @brief Connects to this signal to be notified when page loading is started.
* @return A signal object to connect with.
*/
virtual WebEnginePageLoadErrorSignalType& PageLoadErrorSignal() = 0;
-
};
-} // namespace Dali;
+} // namespace Dali
#endif
namespace Dali
{
-
WebEngine::WebEngine()
{
}
-WebEngine::WebEngine( Internal::Adaptor::WebEngine* internal )
-: BaseHandle( internal )
+WebEngine::WebEngine(Internal::Adaptor::WebEngine* internal)
+: BaseHandle(internal)
{
}
{
Internal::Adaptor::WebEnginePtr engine = Internal::Adaptor::WebEngine::New();
- return WebEngine( engine.Get() );
+ return WebEngine(engine.Get());
}
-WebEngine::WebEngine( const WebEngine& webEngine )
-: BaseHandle( webEngine )
+WebEngine::WebEngine(const WebEngine& webEngine)
+: BaseHandle(webEngine)
{
}
-WebEngine& WebEngine::operator=( const WebEngine& webEngine )
+WebEngine& WebEngine::operator=(const WebEngine& webEngine)
{
- if( *this != webEngine )
+ if(*this != webEngine)
{
- BaseHandle::operator=( webEngine );
+ BaseHandle::operator=(webEngine);
}
return *this;
}
-WebEngine WebEngine::DownCast( BaseHandle handle )
+WebEngine WebEngine::DownCast(BaseHandle handle)
{
- return WebEngine( dynamic_cast< Internal::Adaptor::WebEngine* >( handle.GetObjectPtr() ) );
+ return WebEngine(dynamic_cast<Internal::Adaptor::WebEngine*>(handle.GetObjectPtr()));
}
-void WebEngine::Create( int width, int height, const std::string& locale, const std::string& timezoneId )
+void WebEngine::Create(int width, int height, const std::string& locale, const std::string& timezoneId)
{
- GetImplementation( *this ).Create( width, height, locale, timezoneId );
+ GetImplementation(*this).Create(width, height, locale, timezoneId);
}
void WebEngine::Destroy()
{
- GetImplementation( *this ).Destroy();
+ GetImplementation(*this).Destroy();
}
NativeImageInterfacePtr WebEngine::GetNativeImageSource()
{
- return GetImplementation( *this ).GetNativeImageSource();
+ return GetImplementation(*this).GetNativeImageSource();
}
-void WebEngine::LoadUrl( const std::string& url )
+void WebEngine::LoadUrl(const std::string& url)
{
- return GetImplementation( *this ).LoadUrl( url );
+ return GetImplementation(*this).LoadUrl(url);
}
const std::string& WebEngine::GetUrl()
{
- return GetImplementation( *this ).GetUrl();
+ return GetImplementation(*this).GetUrl();
}
-void WebEngine::LoadHTMLString( const std::string& htmlString )
+void WebEngine::LoadHTMLString(const std::string& htmlString)
{
- GetImplementation( *this ).LoadHTMLString( htmlString );
+ GetImplementation(*this).LoadHTMLString(htmlString);
}
void WebEngine::Reload()
{
- GetImplementation( *this ).Reload();
+ GetImplementation(*this).Reload();
}
void WebEngine::StopLoading()
{
- GetImplementation( *this ).StopLoading();
+ GetImplementation(*this).StopLoading();
}
void WebEngine::Suspend()
{
- GetImplementation( *this ).Suspend();
+ GetImplementation(*this).Suspend();
}
void WebEngine::Resume()
{
- GetImplementation( *this ).Resume();
+ GetImplementation(*this).Resume();
}
bool WebEngine::CanGoForward()
{
- return GetImplementation( *this ).CanGoForward();
+ return GetImplementation(*this).CanGoForward();
}
void WebEngine::GoForward()
{
- GetImplementation( *this ).GoForward();
+ GetImplementation(*this).GoForward();
}
bool WebEngine::CanGoBack()
{
- return GetImplementation( *this ).CanGoBack();
+ return GetImplementation(*this).CanGoBack();
}
void WebEngine::GoBack()
{
- GetImplementation( *this ).GoBack();
+ GetImplementation(*this).GoBack();
}
-void WebEngine::EvaluateJavaScript( const std::string& script, std::function< void( const std::string& ) > resultHandler )
+void WebEngine::EvaluateJavaScript(const std::string& script, std::function<void(const std::string&)> resultHandler)
{
- GetImplementation( *this ).EvaluateJavaScript( script, resultHandler );
+ GetImplementation(*this).EvaluateJavaScript(script, resultHandler);
}
-void WebEngine::AddJavaScriptMessageHandler( const std::string& exposedObjectName, std::function< void( const std::string& ) > handler )
+void WebEngine::AddJavaScriptMessageHandler(const std::string& exposedObjectName, std::function<void(const std::string&)> handler)
{
- GetImplementation( *this ).AddJavaScriptMessageHandler( exposedObjectName, handler );
+ GetImplementation(*this).AddJavaScriptMessageHandler(exposedObjectName, handler);
}
void WebEngine::ClearHistory()
{
- return GetImplementation( *this ).ClearHistory();
+ return GetImplementation(*this).ClearHistory();
}
void WebEngine::ClearCache()
{
- return GetImplementation( *this ).ClearCache();
+ return GetImplementation(*this).ClearCache();
}
void WebEngine::ClearCookies()
{
- return GetImplementation( *this ).ClearCookies();
+ return GetImplementation(*this).ClearCookies();
}
Dali::WebEnginePlugin::CacheModel WebEngine::GetCacheModel() const
{
- return GetImplementation( *this ).GetCacheModel();
+ return GetImplementation(*this).GetCacheModel();
}
-void WebEngine::SetCacheModel( Dali::WebEnginePlugin::CacheModel cacheModel )
+void WebEngine::SetCacheModel(Dali::WebEnginePlugin::CacheModel cacheModel)
{
- GetImplementation( *this ).SetCacheModel( cacheModel );
+ GetImplementation(*this).SetCacheModel(cacheModel);
}
Dali::WebEnginePlugin::CookieAcceptPolicy WebEngine::GetCookieAcceptPolicy() const
{
- return GetImplementation( *this ).GetCookieAcceptPolicy();
+ return GetImplementation(*this).GetCookieAcceptPolicy();
}
-void WebEngine::SetCookieAcceptPolicy( Dali::WebEnginePlugin::CookieAcceptPolicy policy )
+void WebEngine::SetCookieAcceptPolicy(Dali::WebEnginePlugin::CookieAcceptPolicy policy)
{
- GetImplementation( *this ).SetCookieAcceptPolicy( policy );
+ GetImplementation(*this).SetCookieAcceptPolicy(policy);
}
const std::string& WebEngine::GetUserAgent() const
{
- return GetImplementation( *this ).GetUserAgent();
+ return GetImplementation(*this).GetUserAgent();
}
-void WebEngine::SetUserAgent( const std::string& userAgent )
+void WebEngine::SetUserAgent(const std::string& userAgent)
{
- GetImplementation( *this ).SetUserAgent( userAgent );
+ GetImplementation(*this).SetUserAgent(userAgent);
}
bool WebEngine::IsJavaScriptEnabled() const
{
- return GetImplementation( *this ).IsJavaScriptEnabled();
+ return GetImplementation(*this).IsJavaScriptEnabled();
}
-void WebEngine::EnableJavaScript( bool enabled )
+void WebEngine::EnableJavaScript(bool enabled)
{
- GetImplementation( *this ).EnableJavaScript( enabled );
+ GetImplementation(*this).EnableJavaScript(enabled);
}
bool WebEngine::AreImagesAutomaticallyLoaded() const
{
- return GetImplementation( *this ).AreImagesAutomaticallyLoaded();
+ return GetImplementation(*this).AreImagesAutomaticallyLoaded();
}
-void WebEngine::LoadImagesAutomatically( bool automatic )
+void WebEngine::LoadImagesAutomatically(bool automatic)
{
- GetImplementation( *this ).LoadImagesAutomatically( automatic );
+ GetImplementation(*this).LoadImagesAutomatically(automatic);
}
const std::string& WebEngine::GetDefaultTextEncodingName() const
{
- return GetImplementation( *this ).GetDefaultTextEncodingName();
+ return GetImplementation(*this).GetDefaultTextEncodingName();
}
-void WebEngine::SetDefaultTextEncodingName( const std::string& defaultTextEncodingName )
+void WebEngine::SetDefaultTextEncodingName(const std::string& defaultTextEncodingName)
{
- GetImplementation( *this ).SetDefaultTextEncodingName( defaultTextEncodingName );
+ GetImplementation(*this).SetDefaultTextEncodingName(defaultTextEncodingName);
}
int WebEngine::GetDefaultFontSize() const
{
- return GetImplementation( *this ).GetDefaultFontSize();
+ return GetImplementation(*this).GetDefaultFontSize();
}
-void WebEngine::SetDefaultFontSize( int defaultFontSize )
+void WebEngine::SetDefaultFontSize(int defaultFontSize)
{
- GetImplementation( *this ).SetDefaultFontSize( defaultFontSize );
+ GetImplementation(*this).SetDefaultFontSize(defaultFontSize);
}
-void WebEngine::SetSize( int width, int height )
+void WebEngine::SetSize(int width, int height)
{
- return GetImplementation( *this ).SetSize( width, height );
+ return GetImplementation(*this).SetSize(width, height);
}
-bool WebEngine::SendTouchEvent( const TouchEvent& touch )
+bool WebEngine::SendTouchEvent(const TouchEvent& touch)
{
- return GetImplementation( *this ).SendTouchEvent( touch );
+ return GetImplementation(*this).SendTouchEvent(touch);
}
-bool WebEngine::SendKeyEvent( const KeyEvent& event )
+bool WebEngine::SendKeyEvent(const KeyEvent& event)
{
- return GetImplementation( *this ).SendKeyEvent( event );
+ return GetImplementation(*this).SendKeyEvent(event);
}
Dali::WebEnginePlugin::WebEnginePageLoadSignalType& WebEngine::PageLoadStartedSignal()
{
- return GetImplementation( *this ).PageLoadStartedSignal();
+ return GetImplementation(*this).PageLoadStartedSignal();
}
Dali::WebEnginePlugin::WebEnginePageLoadSignalType& WebEngine::PageLoadFinishedSignal()
{
- return GetImplementation( *this ).PageLoadFinishedSignal();
+ return GetImplementation(*this).PageLoadFinishedSignal();
}
Dali::WebEnginePlugin::WebEnginePageLoadErrorSignalType& WebEngine::PageLoadErrorSignal()
{
- return GetImplementation( *this ).PageLoadErrorSignal();
+ return GetImplementation(*this).PageLoadErrorSignal();
}
-} // namespace Dali;
-
+} // namespace Dali
namespace Dali
{
-
namespace Internal
{
-
namespace Adaptor
{
- class WebEngine;
+class WebEngine;
} // namespace Adaptor
} // namespace Internal
class DALI_ADAPTOR_API WebEngine : public BaseHandle
{
public:
-
/**
* @brief Constructor.
*/
*
* @param[in] WebEngine WebEngine to copy. The copied WebEngine will point at the same implementation
*/
- WebEngine( const WebEngine& WebEngine );
+ WebEngine(const WebEngine& WebEngine);
/**
* @brief Assignment operator.
* @param[in] WebEngine The WebEngine to assign from.
* @return The updated WebEngine.
*/
- WebEngine& operator=( const WebEngine& WebEngine );
+ WebEngine& operator=(const WebEngine& WebEngine);
/**
* @brief Downcast a handle to WebEngine handle.
* @param[in] handle Handle to an object
* @return Handle to a WebEngine or an uninitialized handle
*/
- static WebEngine DownCast( BaseHandle handle );
+ static WebEngine DownCast(BaseHandle handle);
/**
* @brief Creates WebEngine instance.
* @param [in] locale The locale of Web
* @param [in] timezoneId The timezoneID of Web
*/
- void Create( int width, int height, const std::string& locale, const std::string& timezoneId );
+ void Create(int width, int height, const std::string& locale, const std::string& timezoneId);
/**
* @brief Destroys WebEngine instance.
*
* @param [in] url The URL of the resource to load
*/
- void LoadUrl( const std::string& url );
+ void LoadUrl(const std::string& url);
/**
* @brief Gets the url.
*
* @param [in] htmlString The string to use as the contents of the web page
*/
- void LoadHTMLString( const std::string& htmlString );
+ void LoadHTMLString(const std::string& htmlString);
/**
* @brief Reloads the Web.
* @param[in] script The JavaScript code
* @param[in] resultHandler The callback function to be called by the JavaScript runtime. This carries evaluation result.
*/
- void EvaluateJavaScript( const std::string& script, std::function< void( const std::string& ) > resultHandler );
+ void EvaluateJavaScript(const std::string& script, std::function<void(const std::string&)> resultHandler);
/**
* @brief Add a message handler into JavaScript.
* @param[in] exposedObjectName The name of exposed object
* @param[in] handler The callback function
*/
- void AddJavaScriptMessageHandler( const std::string& exposedObjectName, std::function< void( const std::string& ) > handler );
+ void AddJavaScriptMessageHandler(const std::string& exposedObjectName, std::function<void(const std::string&)> handler);
/**
* @brief Clears the history of Web.
*
* @param[in] cacheModel The cache model option
*/
- void SetCacheModel( Dali::WebEnginePlugin::CacheModel cacheModel );
+ void SetCacheModel(Dali::WebEnginePlugin::CacheModel cacheModel);
/**
* @brief Gets the cookie acceptance policy. The default is NO_THIRD_PARTY.
*
* @param[in] policy The cookie acceptance policy
*/
- void SetCookieAcceptPolicy( Dali::WebEnginePlugin::CookieAcceptPolicy policy );
+ void SetCookieAcceptPolicy(Dali::WebEnginePlugin::CookieAcceptPolicy policy);
/**
* @brief Get user agent string.
*
* @param[in] userAgent The string value of user agent
*/
- void SetUserAgent( const std::string& userAgent );
+ void SetUserAgent(const std::string& userAgent);
/**
* @brief Returns whether JavaScript can be executable. The default is true.
*
* @param[in] enabled True if JavaScript executing is enabled, false otherwise
*/
- void EnableJavaScript( bool enabled );
+ void EnableJavaScript(bool enabled);
/**
* @brief Returns whether JavaScript can be executable. The default is true.
*
* @param[in] automatic True if images are loaded automatically, false otherwise
*/
- void LoadImagesAutomatically( bool automatic );
+ void LoadImagesAutomatically(bool automatic);
/**
* @brief Gets the default text encoding name.
*
* @param[in] defaultTextEncodingName The default text encoding name
*/
- void SetDefaultTextEncodingName( const std::string& defaultTextEncodingName );
+ void SetDefaultTextEncodingName(const std::string& defaultTextEncodingName);
/**
* @brief Returns the default font size in pixel. The default value is 16.
*
* @param[in] defaultFontSize A new default font size to set
*/
- void SetDefaultFontSize( int defaultFontSize );
+ void SetDefaultFontSize(int defaultFontSize);
/**
* @brief Sets the size of Web Pages.
*/
- void SetSize( int width, int height );
+ void SetSize(int width, int height);
/**
* @brief Sends Touch Events.
*/
- bool SendTouchEvent( const TouchEvent& touch );
+ bool SendTouchEvent(const TouchEvent& touch);
/**
* @brief Sends key Events.
*/
- bool SendKeyEvent( const KeyEvent& event );
+ bool SendKeyEvent(const KeyEvent& event);
/**
* @brief Connects to this signal to be notified when page loading is started.
Dali::WebEnginePlugin::WebEnginePageLoadErrorSignalType& PageLoadErrorSignal();
private: // Not intended for application developers
-
/**
* @brief Internal constructor
*/
- explicit DALI_INTERNAL WebEngine( Internal::Adaptor::WebEngine* internal );
+ explicit DALI_INTERNAL WebEngine(Internal::Adaptor::WebEngine* internal);
};
-} // namespace Dali;
+} // namespace Dali
#endif // DALI_WEB_ENGINE_H
namespace Dali
{
-
namespace DevelWindow
{
-
Window New(Any surface, PositionSize windowPosition, const std::string& name, bool isTransparent)
{
return DevelWindow::New(surface, windowPosition, name, "", isTransparent);
Window newWindow;
const bool isAdaptorAvailable = Dali::Adaptor::IsAvailable();
- bool isNewWindowAllowed = true;
+ bool isNewWindowAllowed = true;
- if (isAdaptorAvailable)
+ if(isAdaptorAvailable)
{
Dali::Adaptor& adaptor = Internal::Adaptor::Adaptor::Get();
- isNewWindowAllowed = Internal::Adaptor::Adaptor::GetImplementation(adaptor).IsMultipleWindowSupported();
+ isNewWindowAllowed = Internal::Adaptor::Adaptor::GetImplementation(adaptor).IsMultipleWindowSupported();
}
- if (isNewWindowAllowed)
+ if(isNewWindowAllowed)
{
Internal::Adaptor::Window* window = Internal::Adaptor::Window::New(surface, windowPosition, name, className, isTransparent);
Integration::SceneHolder sceneHolder = Integration::SceneHolder(window);
- if (isAdaptorAvailable)
+ if(isAdaptorAvailable)
{
Dali::Adaptor& adaptor = Internal::Adaptor::Adaptor::Get();
Internal::Adaptor::Adaptor::GetImplementation(adaptor).AddWindow(sceneHolder);
return newWindow;
}
-void SetPositionSize( Window window, PositionSize positionSize )
+void SetPositionSize(Window window, PositionSize positionSize)
{
- GetImplementation( window ).SetPositionSize( positionSize );
+ GetImplementation(window).SetPositionSize(positionSize);
}
-Window Get( Actor actor )
+Window Get(Actor actor)
{
- return Internal::Adaptor::Window::Get( actor );
+ return Internal::Adaptor::Window::Get(actor);
}
-EventProcessingFinishedSignalType& EventProcessingFinishedSignal( Window window )
+EventProcessingFinishedSignalType& EventProcessingFinishedSignal(Window window)
{
- return GetImplementation( window ).EventProcessingFinishedSignal();
+ return GetImplementation(window).EventProcessingFinishedSignal();
}
-WheelEventSignalType& WheelEventSignal( Window window )
+WheelEventSignalType& WheelEventSignal(Window window)
{
- return GetImplementation( window ).WheelEventSignal();
+ return GetImplementation(window).WheelEventSignal();
}
-VisibilityChangedSignalType& VisibilityChangedSignal( Window window )
+VisibilityChangedSignalType& VisibilityChangedSignal(Window window)
{
- return GetImplementation( window ).VisibilityChangedSignal();
+ return GetImplementation(window).VisibilityChangedSignal();
}
-TransitionEffectEventSignalType& TransitionEffectEventSignal( Window window )
+TransitionEffectEventSignalType& TransitionEffectEventSignal(Window window)
{
- return GetImplementation( window ).TransitionEffectEventSignal();
+ return GetImplementation(window).TransitionEffectEventSignal();
}
-KeyboardRepeatSettingsChangedSignalType& KeyboardRepeatSettingsChangedSignal( Window window )
+KeyboardRepeatSettingsChangedSignalType& KeyboardRepeatSettingsChangedSignal(Window window)
{
- return GetImplementation( window ).KeyboardRepeatSettingsChangedSignal();
+ return GetImplementation(window).KeyboardRepeatSettingsChangedSignal();
}
-void SetParent( Window window, Window parent )
+void SetParent(Window window, Window parent)
{
- GetImplementation( window ).SetParent( parent );
+ GetImplementation(window).SetParent(parent);
}
-void Unparent( Window window )
+void Unparent(Window window)
{
- GetImplementation( window ).Unparent();
+ GetImplementation(window).Unparent();
}
-Window GetParent( Window window )
+Window GetParent(Window window)
{
- return GetImplementation( window ).GetParent();
+ return GetImplementation(window).GetParent();
}
-Window DownCast( BaseHandle handle )
+Window DownCast(BaseHandle handle)
{
- return Window( dynamic_cast<Dali::Internal::Adaptor::Window*>( handle.GetObjectPtr()) );
+ return Window(dynamic_cast<Dali::Internal::Adaptor::Window*>(handle.GetObjectPtr()));
}
-Dali::Window::WindowOrientation GetCurrentOrientation( Window window )
+Dali::Window::WindowOrientation GetCurrentOrientation(Window window)
{
- return GetImplementation( window ).GetCurrentOrientation();
+ return GetImplementation(window).GetCurrentOrientation();
}
-void SetAvailableOrientations( Window window, const Dali::Vector<Dali::Window::WindowOrientation>& orientations )
+void SetAvailableOrientations(Window window, const Dali::Vector<Dali::Window::WindowOrientation>& orientations)
{
- GetImplementation( window ).SetAvailableOrientations( orientations );
+ GetImplementation(window).SetAvailableOrientations(orientations);
}
-int32_t GetNativeId( Window window )
+int32_t GetNativeId(Window window)
{
- return GetImplementation( window ).GetNativeId();
+ return GetImplementation(window).GetNativeId();
}
-void AddFrameRenderedCallback( Window window, std::unique_ptr< CallbackBase > callback, int32_t frameId )
+void AddFrameRenderedCallback(Window window, std::unique_ptr<CallbackBase> callback, int32_t frameId)
{
- GetImplementation( window ).AddFrameRenderedCallback( std::move( callback ), frameId );
+ GetImplementation(window).AddFrameRenderedCallback(std::move(callback), frameId);
}
-void AddFramePresentedCallback( Window window, std::unique_ptr< CallbackBase > callback, int32_t frameId )
+void AddFramePresentedCallback(Window window, std::unique_ptr<CallbackBase> callback, int32_t frameId)
{
- GetImplementation( window ).AddFramePresentedCallback( std::move( callback ), frameId );
+ GetImplementation(window).AddFramePresentedCallback(std::move(callback), frameId);
}
} // namespace DevelWindow
#include <memory>
// INTERNAL INCLUDES
-#include <dali/public-api/common/vector-wrapper.h>
#include <dali/public-api/adaptor-framework/window.h>
+#include <dali/public-api/common/vector-wrapper.h>
namespace Dali
{
*/
enum class EffectState
{
- NONE = 0, ///< None state
- START, ///< Transition effect is started.
- END ///< Transition effect is ended.
+ NONE = 0, ///< None state
+ START, ///< Transition effect is started.
+ END ///< Transition effect is ended.
};
/**
* @brief Enumeration for transition effect's type.
*/
-enum class EffectType
+enum class EffectType
{
- NONE = 0, ///< None type
- SHOW, ///< Window show effect.
- HIDE, ///< Window hide effect.
+ NONE = 0, ///< None type
+ SHOW, ///< Window show effect.
+ HIDE, ///< Window hide effect.
};
-typedef Signal< void () > EventProcessingFinishedSignalType; ///< Event Processing finished signal type
+typedef Signal<void()> EventProcessingFinishedSignalType; ///< Event Processing finished signal type
-typedef Signal< void (const KeyEvent&) > KeyEventSignalType; ///< Key event signal type
+typedef Signal<void(const KeyEvent&)> KeyEventSignalType; ///< Key event signal type
-typedef Signal< void (const TouchEvent&) > TouchEventSignalType; ///< Touch signal type
+typedef Signal<void(const TouchEvent&)> TouchEventSignalType; ///< Touch signal type
-typedef Signal< void (const WheelEvent&) > WheelEventSignalType; ///< Touched signal type
+typedef Signal<void(const WheelEvent&)> WheelEventSignalType; ///< Touched signal type
-typedef Signal< void ( Window, bool ) > VisibilityChangedSignalType; ///< Visibility changed signal type
+typedef Signal<void(Window, bool)> VisibilityChangedSignalType; ///< Visibility changed signal type
-typedef Signal< void (Window, EffectState, EffectType) > TransitionEffectEventSignalType; ///< Effect signal type and state
+typedef Signal<void(Window, EffectState, EffectType)> TransitionEffectEventSignalType; ///< Effect signal type and state
-typedef Signal< void () > KeyboardRepeatSettingsChangedSignalType; ///< Keyboard repeat settings changed signal type
+typedef Signal<void()> KeyboardRepeatSettingsChangedSignalType; ///< Keyboard repeat settings changed signal type
/**
* @brief Creates an initialized handle to a new Window.
* @param[in] window The window instance
* @param[in] positionSize The new window position and size
*/
-DALI_ADAPTOR_API void SetPositionSize( Window window, PositionSize positionSize );
+DALI_ADAPTOR_API void SetPositionSize(Window window, PositionSize positionSize);
/**
* @brief Retrieve the window that the given actor is added to.
* @param[in] actor The actor
* @return The window the actor is added to or an empty handle if the actor is not added to any window.
*/
-DALI_ADAPTOR_API Window Get( Actor actor );
+DALI_ADAPTOR_API Window Get(Actor actor);
/**
* @brief This signal is emitted just after the event processing is finished.
* @param[in] window The window instance
* @return The signal to connect to
*/
-DALI_ADAPTOR_API EventProcessingFinishedSignalType& EventProcessingFinishedSignal( Window window );
+DALI_ADAPTOR_API EventProcessingFinishedSignalType& EventProcessingFinishedSignal(Window window);
/**
* @brief This signal is emitted when wheel event is received.
* @param[in] window The window instance
* @return The signal to connect to
*/
-DALI_ADAPTOR_API WheelEventSignalType& WheelEventSignal( Window window );
+DALI_ADAPTOR_API WheelEventSignalType& WheelEventSignal(Window window);
/**
* @brief This signal is emitted when the window is shown or hidden.
* @param[in] window The window instance
* @return The signal to connect to
*/
-DALI_ADAPTOR_API VisibilityChangedSignalType& VisibilityChangedSignal( Window window );
+DALI_ADAPTOR_API VisibilityChangedSignalType& VisibilityChangedSignal(Window window);
/**
* @brief This signal is emitted for transition effect.
* @param[in] window The window instance
* @return The signal to connect to
*/
-DALI_ADAPTOR_API TransitionEffectEventSignalType& TransitionEffectEventSignal( Window window );
+DALI_ADAPTOR_API TransitionEffectEventSignalType& TransitionEffectEventSignal(Window window);
/**
* @brief This signal is emitted just after the keyboard repeat setting is changed globally.
* @param[in] window The window instance
* @return The signal to connect to
*/
-DALI_ADAPTOR_API KeyboardRepeatSettingsChangedSignalType& KeyboardRepeatSettingsChangedSignal( Window window );
+DALI_ADAPTOR_API KeyboardRepeatSettingsChangedSignalType& KeyboardRepeatSettingsChangedSignal(Window window);
/**
* @brief Sets parent window of the window.
* @param[in] window The window instance
* @param[in] parent The parent window instance
*/
-DALI_ADAPTOR_API void SetParent( Window window, Window parent );
+DALI_ADAPTOR_API void SetParent(Window window, Window parent);
/**
* @brief Unsets parent window of the window.
*
* @param[in] window The window instance
*/
-DALI_ADAPTOR_API void Unparent( Window window );
+DALI_ADAPTOR_API void Unparent(Window window);
/**
* @brief Gets parent window of the window.
* @param[in] window The window instance
* @return The parent window of the window
*/
-DALI_ADAPTOR_API Window GetParent( Window window );
+DALI_ADAPTOR_API Window GetParent(Window window);
/**
* @brief Downcast sceneHolder to window
* @param[in] handle The handle need to downcast
* @return The window cast from SceneHolder
*/
-DALI_ADAPTOR_API Window DownCast( BaseHandle handle );
+DALI_ADAPTOR_API Window DownCast(BaseHandle handle);
/**
* @brief Gets current orientation of the window.
* @param[in] window The window instance
* @return The current window orientation if previously set, or none
*/
-DALI_ADAPTOR_API Dali::Window::WindowOrientation GetCurrentOrientation( Window window );
+DALI_ADAPTOR_API Dali::Window::WindowOrientation GetCurrentOrientation(Window window);
/**
* @brief Sets available orientations of the window.
* @param[in] window The window instance
* @param[in] orientations The available orientation list to add
*/
-DALI_ADAPTOR_API void SetAvailableOrientations( Window window, const Dali::Vector<Dali::Window::WindowOrientation>& orientations );
+DALI_ADAPTOR_API void SetAvailableOrientations(Window window, const Dali::Vector<Dali::Window::WindowOrientation>& orientations);
/**
* @brief Gets current window ID.
*
* @param[in] window The window instance
*/
-DALI_ADAPTOR_API int32_t GetNativeId( Window window );
+DALI_ADAPTOR_API int32_t GetNativeId(Window window);
/**
* @brief Adds a callback that is called when the frame rendering is done by the graphics driver.
*
* @note Ownership of the callback is passed onto this class.
*/
-DALI_ADAPTOR_API void AddFrameRenderedCallback( Window window, std::unique_ptr< CallbackBase > callback, int32_t frameId );
+DALI_ADAPTOR_API void AddFrameRenderedCallback(Window window, std::unique_ptr<CallbackBase> callback, int32_t frameId);
/**
* @brief Adds a callback that is called when the frame is displayed on the display.
*
* @note Ownership of the callback is passed onto this class.
*/
-DALI_ADAPTOR_API void AddFramePresentedCallback( Window window, std::unique_ptr< CallbackBase > callback, int32_t frameId );
+DALI_ADAPTOR_API void AddFramePresentedCallback(Window window, std::unique_ptr<CallbackBase> callback, int32_t frameId);
} // namespace DevelWindow
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace TextAbstraction
{
-
BidirectionalSupport::BidirectionalSupport()
{
}
{
}
-BidirectionalSupport::BidirectionalSupport( Internal::BidirectionalSupport* implementation )
-: BaseHandle( implementation )
+BidirectionalSupport::BidirectionalSupport(Internal::BidirectionalSupport* implementation)
+: BaseHandle(implementation)
{
}
return Internal::BidirectionalSupport::Get();
}
-BidiInfoIndex BidirectionalSupport::CreateInfo( const Character* const paragraph,
- Length numberOfCharacters,
- bool matchSystemLanguageDirection,
- LayoutDirection::Type layoutDirection )
+BidiInfoIndex BidirectionalSupport::CreateInfo(const Character* const paragraph,
+ Length numberOfCharacters,
+ bool matchSystemLanguageDirection,
+ LayoutDirection::Type layoutDirection)
{
- return GetImplementation( *this ).CreateInfo( paragraph,
- numberOfCharacters,
- matchSystemLanguageDirection,
- layoutDirection );
+ return GetImplementation(*this).CreateInfo(paragraph,
+ numberOfCharacters,
+ matchSystemLanguageDirection,
+ layoutDirection);
}
-void BidirectionalSupport::DestroyInfo( BidiInfoIndex bidiInfoIndex )
+void BidirectionalSupport::DestroyInfo(BidiInfoIndex bidiInfoIndex)
{
- GetImplementation( *this ).DestroyInfo( bidiInfoIndex );
+ GetImplementation(*this).DestroyInfo(bidiInfoIndex);
}
-void BidirectionalSupport::Reorder( BidiInfoIndex bidiInfoIndex,
- CharacterIndex firstCharacterIndex,
- Length numberOfCharacters,
- CharacterIndex* visualToLogicalMap )
+void BidirectionalSupport::Reorder(BidiInfoIndex bidiInfoIndex,
+ CharacterIndex firstCharacterIndex,
+ Length numberOfCharacters,
+ CharacterIndex* visualToLogicalMap)
{
- GetImplementation( *this ).Reorder( bidiInfoIndex,
- firstCharacterIndex,
- numberOfCharacters,
- visualToLogicalMap );
+ GetImplementation(*this).Reorder(bidiInfoIndex,
+ firstCharacterIndex,
+ numberOfCharacters,
+ visualToLogicalMap);
}
-bool BidirectionalSupport::GetMirroredText( Character* text,
- CharacterDirection* directions,
- Length numberOfCharacters )
+bool BidirectionalSupport::GetMirroredText(Character* text,
+ CharacterDirection* directions,
+ Length numberOfCharacters)
{
- return GetImplementation( *this ).GetMirroredText( text,
- directions,
- numberOfCharacters );
+ return GetImplementation(*this).GetMirroredText(text,
+ directions,
+ numberOfCharacters);
}
-bool BidirectionalSupport::GetParagraphDirection( BidiInfoIndex bidiInfoIndex ) const
+bool BidirectionalSupport::GetParagraphDirection(BidiInfoIndex bidiInfoIndex) const
{
- return GetImplementation( *this ).GetParagraphDirection( bidiInfoIndex );
+ return GetImplementation(*this).GetParagraphDirection(bidiInfoIndex);
}
-void BidirectionalSupport::GetCharactersDirection( BidiInfoIndex bidiInfoIndex,
- CharacterDirection* directions,
- Length numberOfCharacters )
+void BidirectionalSupport::GetCharactersDirection(BidiInfoIndex bidiInfoIndex,
+ CharacterDirection* directions,
+ Length numberOfCharacters)
{
- GetImplementation( *this ).GetCharactersDirection( bidiInfoIndex,
- directions,
- numberOfCharacters );
+ GetImplementation(*this).GetCharactersDirection(bidiInfoIndex,
+ directions,
+ numberOfCharacters);
}
} // namespace TextAbstraction
#define DALI_PLATFORM_TEXT_ABSTRACTION_BIDIRECTIONAL_SUPPORT_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
#include <dali/devel-api/text-abstraction/text-abstraction-definitions.h>
// EXTERNAL INCLUDES
-#include <dali/public-api/object/base-handle.h>
#include <dali/public-api/actors/actor-enumerations.h>
+#include <dali/public-api/object/base-handle.h>
// INTERNAL INCLUDES
#include <dali/public-api/dali-adaptor-common.h>
namespace Dali
{
-
namespace TextAbstraction
{
-
namespace Internal DALI_INTERNAL
{
-
class BidirectionalSupport;
-} // Internal
+} // namespace DALI_INTERNAL
/**
* BidirectionalSupport API
*/
class DALI_ADAPTOR_API BidirectionalSupport : public BaseHandle
{
-
public:
-
/**
* @brief Create an uninitialized TextAbstraction handle.
*
*
* @param[in] implementation a pointer to the internal bidirectional support object.
*/
- explicit DALI_INTERNAL BidirectionalSupport( Internal::BidirectionalSupport* implementation );
+ explicit DALI_INTERNAL BidirectionalSupport(Internal::BidirectionalSupport* implementation);
/**
* @brief Retrieve a handle to the BidirectionalSupport instance.
* @param[in] layoutDirection The direction of the system language.
* @return An index of an object inside a table storing the bidirectional data.
*/
- BidiInfoIndex CreateInfo( const Character* const paragraph,
- Length numberOfCharacters,
- bool matchSystemLanguageDirection,
- LayoutDirection::Type layoutDirection );
+ BidiInfoIndex CreateInfo(const Character* const paragraph,
+ Length numberOfCharacters,
+ bool matchSystemLanguageDirection,
+ LayoutDirection::Type layoutDirection);
/**
* @brief Destroys the bidirectional data.
*
* @param[in] bidiInfoIndex The index to the of the object inside the table storing the bidirectional data for the current paragraph.
*/
- void DestroyInfo( BidiInfoIndex bidiInfoIndex );
+ void DestroyInfo(BidiInfoIndex bidiInfoIndex);
/**
* @brief Reorders a line of a paragraph.
* @param[in] numberOfCharacters The number of characters of the line.
* @param[out] visualToLogicalMap The visual to logical conversion map.
*/
- void Reorder( BidiInfoIndex bidiInfoIndex,
- CharacterIndex firstCharacterIndex,
- Length numberOfCharacters,
- CharacterIndex* visualToLogicalMap );
+ void Reorder(BidiInfoIndex bidiInfoIndex,
+ CharacterIndex firstCharacterIndex,
+ Length numberOfCharacters,
+ CharacterIndex* visualToLogicalMap);
/**
* @brief Replaces any character which could be mirrored.
*
* @return @e true if a character has been replaced.
*/
- bool GetMirroredText( Character* text,
- CharacterDirection* directions,
- Length numberOfCharacters );
+ bool GetMirroredText(Character* text,
+ CharacterDirection* directions,
+ Length numberOfCharacters);
/**
* @brief Retrieves the paragrpah's direction.
*
* @return @e true if the paragraph is right to left, otherwise @e false.
*/
- bool GetParagraphDirection( BidiInfoIndex bidiInfoIndex ) const;
+ bool GetParagraphDirection(BidiInfoIndex bidiInfoIndex) const;
/**
* @brief Retrieves the character's directions.
* @param[out] directions The direction, @e false is left to right and @e true is right to left, of each character of the paragraph.
* @param[in] numberOfCharacters The number of characters.
*/
- void GetCharactersDirection( BidiInfoIndex bidiInfoIndex,
- CharacterDirection* directions,
- Length numberOfCharacters );
+ void GetCharactersDirection(BidiInfoIndex bidiInfoIndex,
+ CharacterDirection* directions,
+ Length numberOfCharacters);
};
} // namespace TextAbstraction
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace TextAbstraction
{
-
BitmapGlyph::BitmapGlyph()
: url{},
- utf32{ 0u },
- ascender{ 0.f },
- descender{ 0.f }
-{}
-
-BitmapGlyph::BitmapGlyph( const std::string& url, GlyphIndex utf32, float ascender, float descender )
-: url{ url },
- utf32{ utf32 },
- ascender{ ascender },
- descender{ descender }
-{}
+ utf32{0u},
+ ascender{0.f},
+ descender{0.f}
+{
+}
+
+BitmapGlyph::BitmapGlyph(const std::string& url, GlyphIndex utf32, float ascender, float descender)
+: url{url},
+ utf32{utf32},
+ ascender{ascender},
+ descender{descender}
+{
+}
BitmapGlyph::~BitmapGlyph()
-{}
+{
+}
BitmapFont::BitmapFont()
: glyphs{},
name{},
- ascender{ 0.f },
- descender{ 0.f },
- underlinePosition{ 0.f },
- underlineThickness{ 1.f },
- isColorFont{ false }
-{}
+ ascender{0.f},
+ descender{0.f},
+ underlinePosition{0.f},
+ underlineThickness{1.f},
+ isColorFont{false}
+{
+}
BitmapFont::~BitmapFont()
-{}
+{
+}
} // namespace TextAbstraction
} // namespace Dali
-
#define DALI_TEXT_ABSTRACTION_BITMAP_FONT_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
// INTERNAL INCLUDES
#include <dali/devel-api/text-abstraction/text-abstraction-definitions.h>
-
-
namespace Dali
{
-
namespace TextAbstraction
{
-
/**
* @brief Struct that stores the needed info to create a bitmap glyph.
*
* @param[in] ascender The ascender of the glyph.
* @param[in] descender The descender of the glyph.
*/
- BitmapGlyph( const std::string& url, GlyphIndex utf32, float ascender, float descender );
+ BitmapGlyph(const std::string& url, GlyphIndex utf32, float ascender, float descender);
/**
* @brief Default destructor.
*/
~BitmapGlyph();
- std::string url; ///< The url of the glyph's bitmap.
- GlyphIndex utf32; ///< The id of the glyph encoded in utf32.
- float ascender; ///< The ascender in pixels. The distance from the base line to the top of the glyph.
- float descender; ///< The descender in pixels. The distance from the base line to the bottom of the glyph.
+ std::string url; ///< The url of the glyph's bitmap.
+ GlyphIndex utf32; ///< The id of the glyph encoded in utf32.
+ float ascender; ///< The ascender in pixels. The distance from the base line to the top of the glyph.
+ float descender; ///< The descender in pixels. The distance from the base line to the bottom of the glyph.
};
/**
*/
~BitmapFont();
- std::vector<BitmapGlyph> glyphs; ///< The glyphs of the font.
- std::string name; ///< The name of the font.
- float ascender; ///< The ascender in pixels. Maximum ascender of all the glyphs.
- float descender; ///< The descender in pixels. Minimum descender of all the glyphs.
- float underlinePosition; ///< The position in pixels of the underline from the base line.
- float underlineThickness; ///< The thickness in pixels of the underline.
- bool isColorFont:1; ///< Whether the glyphs of this font have their own colors.
+ std::vector<BitmapGlyph> glyphs; ///< The glyphs of the font.
+ std::string name; ///< The name of the font.
+ float ascender; ///< The ascender in pixels. Maximum ascender of all the glyphs.
+ float descender; ///< The descender in pixels. Minimum descender of all the glyphs.
+ float underlinePosition; ///< The position in pixels of the underline from the base line.
+ float underlineThickness; ///< The thickness in pixels of the underline.
+ bool isColorFont : 1; ///< Whether the glyphs of this font have their own colors.
};
} // namespace TextAbstraction
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace TextAbstraction
{
-
-const PointSize26Dot6 FontClient::DEFAULT_POINT_SIZE = 768u; // 12*64
-const float FontClient::DEFAULT_ITALIC_ANGLE = 12.f * Dali::Math::PI_OVER_180; // FreeType documentation states the software italic is done by doing a horizontal shear of 12 degrees (file ftsynth.h).
+const PointSize26Dot6 FontClient::DEFAULT_POINT_SIZE = 768u; // 12*64
+const float FontClient::DEFAULT_ITALIC_ANGLE = 12.f * Dali::Math::PI_OVER_180; // FreeType documentation states the software italic is done by doing a horizontal shear of 12 degrees (file ftsynth.h).
FontClient::GlyphBufferData::GlyphBufferData()
-: buffer{ nullptr },
- width{ 0u },
- height{ 0u },
- outlineOffsetX{ 0 },
- outlineOffsetY{ 0 },
- format{ Pixel::A8 },
- isColorEmoji{ false },
- isColorBitmap{ false }
+: buffer{nullptr},
+ width{0u},
+ height{0u},
+ outlineOffsetX{0},
+ outlineOffsetY{0},
+ format{Pixel::A8},
+ isColorEmoji{false},
+ isColorBitmap{false}
{
}
{
}
-FontClient::FontClient( const FontClient& handle )
-: BaseHandle( handle )
+FontClient::FontClient(const FontClient& handle)
+: BaseHandle(handle)
{
}
-FontClient& FontClient::operator=( const FontClient& handle )
+FontClient& FontClient::operator=(const FontClient& handle)
{
- BaseHandle::operator=( handle );
+ BaseHandle::operator=(handle);
return *this;
}
GetImplementation(*this).ClearCache();
}
-void FontClient::SetDpi( unsigned int horizontalDpi, unsigned int verticalDpi )
+void FontClient::SetDpi(unsigned int horizontalDpi, unsigned int verticalDpi)
{
- GetImplementation(*this).SetDpi( horizontalDpi, verticalDpi );
+ GetImplementation(*this).SetDpi(horizontalDpi, verticalDpi);
}
-void FontClient::GetDpi( unsigned int& horizontalDpi, unsigned int& verticalDpi )
+void FontClient::GetDpi(unsigned int& horizontalDpi, unsigned int& verticalDpi)
{
- GetImplementation(*this).GetDpi( horizontalDpi, verticalDpi );
+ GetImplementation(*this).GetDpi(horizontalDpi, verticalDpi);
}
int FontClient::GetDefaultFontSize()
GetImplementation(*this).ResetSystemDefaults();
}
-void FontClient::GetDefaultFonts( FontList& defaultFonts )
+void FontClient::GetDefaultFonts(FontList& defaultFonts)
{
- GetImplementation(*this).GetDefaultFonts( defaultFonts );
+ GetImplementation(*this).GetDefaultFonts(defaultFonts);
}
-void FontClient::GetDefaultPlatformFontDescription( FontDescription& fontDescription )
+void FontClient::GetDefaultPlatformFontDescription(FontDescription& fontDescription)
{
- GetImplementation(*this).GetDefaultPlatformFontDescription( fontDescription );
+ GetImplementation(*this).GetDefaultPlatformFontDescription(fontDescription);
}
-void FontClient::GetSystemFonts( FontList& systemFonts )
+void FontClient::GetSystemFonts(FontList& systemFonts)
{
- GetImplementation(*this).GetSystemFonts( systemFonts );
+ GetImplementation(*this).GetSystemFonts(systemFonts);
}
-void FontClient::GetDescription( FontId id, FontDescription& fontDescription )
+void FontClient::GetDescription(FontId id, FontDescription& fontDescription)
{
- GetImplementation(*this).GetDescription( id, fontDescription );
+ GetImplementation(*this).GetDescription(id, fontDescription);
}
-PointSize26Dot6 FontClient::GetPointSize( FontId id )
+PointSize26Dot6 FontClient::GetPointSize(FontId id)
{
- return GetImplementation(*this).GetPointSize( id );
+ return GetImplementation(*this).GetPointSize(id);
}
-bool FontClient::IsCharacterSupportedByFont( FontId fontId, Character character )
+bool FontClient::IsCharacterSupportedByFont(FontId fontId, Character character)
{
- return GetImplementation(*this).IsCharacterSupportedByFont( fontId, character );
+ return GetImplementation(*this).IsCharacterSupportedByFont(fontId, character);
}
-FontId FontClient::FindDefaultFont( Character charcode,
- PointSize26Dot6 requestedPointSize,
- bool preferColor )
+FontId FontClient::FindDefaultFont(Character charcode,
+ PointSize26Dot6 requestedPointSize,
+ bool preferColor)
{
- return GetImplementation(*this).FindDefaultFont( charcode,
- requestedPointSize,
- preferColor );
+ return GetImplementation(*this).FindDefaultFont(charcode,
+ requestedPointSize,
+ preferColor);
}
-FontId FontClient::FindFallbackFont( Character charcode,
- const FontDescription& preferredFontDescription,
- PointSize26Dot6 requestedPointSize,
- bool preferColor )
+FontId FontClient::FindFallbackFont(Character charcode,
+ const FontDescription& preferredFontDescription,
+ PointSize26Dot6 requestedPointSize,
+ bool preferColor)
{
- return GetImplementation(*this).FindFallbackFont( charcode, preferredFontDescription, requestedPointSize, preferColor );
+ return GetImplementation(*this).FindFallbackFont(charcode, preferredFontDescription, requestedPointSize, preferColor);
}
-FontId FontClient::GetFontId( const FontPath& path, PointSize26Dot6 requestedPointSize, FaceIndex faceIndex )
+FontId FontClient::GetFontId(const FontPath& path, PointSize26Dot6 requestedPointSize, FaceIndex faceIndex)
{
- return GetImplementation(*this).GetFontId( path, requestedPointSize, faceIndex );
+ return GetImplementation(*this).GetFontId(path, requestedPointSize, faceIndex);
}
-FontId FontClient::GetFontId( const FontDescription& fontDescription,
- PointSize26Dot6 requestedPointSize,
- FaceIndex faceIndex )
+FontId FontClient::GetFontId(const FontDescription& fontDescription,
+ PointSize26Dot6 requestedPointSize,
+ FaceIndex faceIndex)
{
- return GetImplementation(*this).GetFontId( fontDescription,
- requestedPointSize,
- faceIndex );
+ return GetImplementation(*this).GetFontId(fontDescription,
+ requestedPointSize,
+ faceIndex);
}
-FontId FontClient::GetFontId( const BitmapFont& bitmapFont )
+FontId FontClient::GetFontId(const BitmapFont& bitmapFont)
{
- return GetImplementation(*this).GetFontId( bitmapFont );
+ return GetImplementation(*this).GetFontId(bitmapFont);
}
-bool FontClient::IsScalable( const FontPath& path )
+bool FontClient::IsScalable(const FontPath& path)
{
- return GetImplementation(*this).IsScalable( path );
+ return GetImplementation(*this).IsScalable(path);
}
-bool FontClient::IsScalable( const FontDescription& fontDescription )
+bool FontClient::IsScalable(const FontDescription& fontDescription)
{
- return GetImplementation(*this).IsScalable( fontDescription );
+ return GetImplementation(*this).IsScalable(fontDescription);
}
-void FontClient::GetFixedSizes( const FontPath& path, Dali::Vector< PointSize26Dot6>& sizes )
+void FontClient::GetFixedSizes(const FontPath& path, Dali::Vector<PointSize26Dot6>& sizes)
{
- GetImplementation(*this).GetFixedSizes( path, sizes );
+ GetImplementation(*this).GetFixedSizes(path, sizes);
}
-void FontClient::GetFixedSizes( const FontDescription& fontDescription,
- Dali::Vector< PointSize26Dot6 >& sizes )
+void FontClient::GetFixedSizes(const FontDescription& fontDescription,
+ Dali::Vector<PointSize26Dot6>& sizes)
{
- GetImplementation(*this).GetFixedSizes( fontDescription, sizes );
+ GetImplementation(*this).GetFixedSizes(fontDescription, sizes);
}
-bool FontClient::HasItalicStyle( FontId fontId ) const
+bool FontClient::HasItalicStyle(FontId fontId) const
{
- return GetImplementation(*this).HasItalicStyle( fontId );
+ return GetImplementation(*this).HasItalicStyle(fontId);
}
-void FontClient::GetFontMetrics( FontId fontId, FontMetrics& metrics )
+void FontClient::GetFontMetrics(FontId fontId, FontMetrics& metrics)
{
- GetImplementation(*this).GetFontMetrics( fontId, metrics );
+ GetImplementation(*this).GetFontMetrics(fontId, metrics);
}
-GlyphIndex FontClient::GetGlyphIndex( FontId fontId, Character charcode )
+GlyphIndex FontClient::GetGlyphIndex(FontId fontId, Character charcode)
{
- return GetImplementation(*this).GetGlyphIndex( fontId, charcode );
+ return GetImplementation(*this).GetGlyphIndex(fontId, charcode);
}
-bool FontClient::GetGlyphMetrics( GlyphInfo* array, uint32_t size, GlyphType type, bool horizontal )
+bool FontClient::GetGlyphMetrics(GlyphInfo* array, uint32_t size, GlyphType type, bool horizontal)
{
- return GetImplementation(*this).GetGlyphMetrics( array, size, type, horizontal );
+ return GetImplementation(*this).GetGlyphMetrics(array, size, type, horizontal);
}
-void FontClient::CreateBitmap( FontId fontId, GlyphIndex glyphIndex, bool isItalicRequired, bool isBoldRequired, GlyphBufferData& data, int outlineWidth )
+void FontClient::CreateBitmap(FontId fontId, GlyphIndex glyphIndex, bool isItalicRequired, bool isBoldRequired, GlyphBufferData& data, int outlineWidth)
{
- GetImplementation(*this).CreateBitmap( fontId, glyphIndex, isItalicRequired, isBoldRequired, data, outlineWidth );
+ GetImplementation(*this).CreateBitmap(fontId, glyphIndex, isItalicRequired, isBoldRequired, data, outlineWidth);
}
-PixelData FontClient::CreateBitmap( FontId fontId, GlyphIndex glyphIndex, int outlineWidth )
+PixelData FontClient::CreateBitmap(FontId fontId, GlyphIndex glyphIndex, int outlineWidth)
{
- return GetImplementation(*this).CreateBitmap( fontId, glyphIndex, outlineWidth );
+ return GetImplementation(*this).CreateBitmap(fontId, glyphIndex, outlineWidth);
}
-void FontClient::CreateVectorBlob( FontId fontId, GlyphIndex glyphIndex, VectorBlob*& blob, unsigned int& blobLength, unsigned int& nominalWidth, unsigned int& nominalHeight )
+void FontClient::CreateVectorBlob(FontId fontId, GlyphIndex glyphIndex, VectorBlob*& blob, unsigned int& blobLength, unsigned int& nominalWidth, unsigned int& nominalHeight)
{
- GetImplementation(*this).CreateVectorBlob( fontId, glyphIndex, blob, blobLength, nominalWidth, nominalHeight );
+ GetImplementation(*this).CreateVectorBlob(fontId, glyphIndex, blob, blobLength, nominalWidth, nominalHeight);
}
-const GlyphInfo& FontClient::GetEllipsisGlyph( PointSize26Dot6 requestedPointSize )
+const GlyphInfo& FontClient::GetEllipsisGlyph(PointSize26Dot6 requestedPointSize)
{
- return GetImplementation(*this).GetEllipsisGlyph( requestedPointSize );
+ return GetImplementation(*this).GetEllipsisGlyph(requestedPointSize);
}
-bool FontClient::IsColorGlyph( FontId fontId, GlyphIndex glyphIndex )
+bool FontClient::IsColorGlyph(FontId fontId, GlyphIndex glyphIndex)
{
- return GetImplementation(*this).IsColorGlyph( fontId, glyphIndex );
+ return GetImplementation(*this).IsColorGlyph(fontId, glyphIndex);
}
-bool FontClient::AddCustomFontDirectory( const FontPath& path )
+bool FontClient::AddCustomFontDirectory(const FontPath& path)
{
- return GetImplementation(*this).AddCustomFontDirectory( path );
+ return GetImplementation(*this).AddCustomFontDirectory(path);
}
GlyphIndex FontClient::CreateEmbeddedItem(const EmbeddedItemDescription& description, Pixel::Format& pixelFormat)
{
- return GetImplementation(*this).CreateEmbeddedItem( description, pixelFormat);
+ return GetImplementation(*this).CreateEmbeddedItem(description, pixelFormat);
}
-FontClient::FontClient( Internal::FontClient* internal )
-: BaseHandle( internal )
+FontClient::FontClient(Internal::FontClient* internal)
+: BaseHandle(internal)
{
}
*/
// INTERNAL INCLUDES
-#include <dali/public-api/common/dali-vector.h>
-#include <dali/public-api/images/pixel-data.h>
-#include <dali/public-api/object/base-handle.h>
#include <dali/devel-api/text-abstraction/font-list.h>
#include <dali/devel-api/text-abstraction/text-abstraction-definitions.h>
+#include <dali/public-api/common/dali-vector.h>
#include <dali/public-api/dali-adaptor-common.h>
+#include <dali/public-api/images/pixel-data.h>
+#include <dali/public-api/object/base-handle.h>
namespace Dali
{
-
namespace TextAbstraction
{
-
struct FontMetrics;
struct GlyphInfo;
struct BitmapFont;
class DALI_ADAPTOR_API FontClient : public BaseHandle
{
public:
- static const PointSize26Dot6 DEFAULT_POINT_SIZE; ///< The default point size.
- static const float DEFAULT_ITALIC_ANGLE; ///< The default software italic angle in radians.
+ static const PointSize26Dot6 DEFAULT_POINT_SIZE; ///< The default point size.
+ static const float DEFAULT_ITALIC_ANGLE; ///< The default software italic angle in radians.
/**
* @brief Struct used to retrieve the glyph's bitmap.
*/
~GlyphBufferData();
- unsigned char* buffer; ///< The glyph's bitmap buffer data.
- unsigned int width; ///< The width of the bitmap.
- unsigned int height; ///< The height of the bitmap.
- int outlineOffsetX; ///< The additional horizontal offset to be added for the glyph's position for outline.
- int outlineOffsetY; ///< The additional vertical offset to be added for the glyph's position for outline.
- Pixel::Format format; ///< The pixel's format of the bitmap.
- bool isColorEmoji:1; ///< Whether the glyph is an emoji.
- bool isColorBitmap:1; ///< Whether the glyph is a color bitmap.
+ unsigned char* buffer; ///< The glyph's bitmap buffer data.
+ unsigned int width; ///< The width of the bitmap.
+ unsigned int height; ///< The height of the bitmap.
+ int outlineOffsetX; ///< The additional horizontal offset to be added for the glyph's position for outline.
+ int outlineOffsetY; ///< The additional vertical offset to be added for the glyph's position for outline.
+ Pixel::Format format; ///< The pixel's format of the bitmap.
+ bool isColorEmoji : 1; ///< Whether the glyph is an emoji.
+ bool isColorBitmap : 1; ///< Whether the glyph is a color bitmap.
};
/**
};
public:
-
/**
* @brief Retrieve a handle to the FontClient instance.
*
*
* @param[in] handle A reference to the copied handle.
*/
- FontClient( const FontClient& handle );
+ FontClient(const FontClient& handle);
/**
* @brief This assignment operator is required for (smart) pointer semantics.
* @param [in] handle A reference to the copied handle.
* @return A reference to this.
*/
- FontClient& operator=( const FontClient& handle );
+ FontClient& operator=(const FontClient& handle);
////////////////////////////////////////
// Font management and validation.
* @param[in] horizontalDpi The horizontal resolution in DPI.
* @param[in] verticalDpi The vertical resolution in DPI.
*/
- void SetDpi( unsigned int horizontalDpi, unsigned int verticalDpi );
+ void SetDpi(unsigned int horizontalDpi, unsigned int verticalDpi);
/**
* @brief Retrieves the DPI previously set to the target window.
* @param[out] horizontalDpi The horizontal resolution in DPI.
* @param[out] verticalDpi The vertical resolution in DPI.
*/
- void GetDpi( unsigned int& horizontalDpi, unsigned int& verticalDpi );
+ void GetDpi(unsigned int& horizontalDpi, unsigned int& verticalDpi);
/**
* @brief Called by Dali to retrieve the default font size for the platform.
*
* @param[out] defaultFonts A list of default font paths, family, width, weight and slant.
*/
- void GetDefaultFonts( FontList& defaultFonts );
+ void GetDefaultFonts(FontList& defaultFonts);
/**
* @brief Retrieve the active default font from the system.
*
* @param[out] fontDescription font structure describing the default font.
*/
- void GetDefaultPlatformFontDescription( FontDescription& fontDescription );
+ void GetDefaultPlatformFontDescription(FontDescription& fontDescription);
/**
* @brief Retrieve the list of fonts supported by the system.
*
* @param[out] systemFonts A list of font paths, family, width, weight and slant.
*/
- void GetSystemFonts( FontList& systemFonts );
+ void GetSystemFonts(FontList& systemFonts);
/**
* @brief Retrieves the font description of a given font @p id.
* @param[in] id The font identifier.
* @param[out] fontDescription The path, family & style (width, weight and slant) describing the font.
*/
- void GetDescription( FontId id, FontDescription& fontDescription );
+ void GetDescription(FontId id, FontDescription& fontDescription);
/**
* @brief Retrieves the font point size of a given font @p id.
*
* @return The point size in 26.6 fractional points.
*/
- PointSize26Dot6 GetPointSize( FontId id );
+ PointSize26Dot6 GetPointSize(FontId id);
/**
* @brief Whether the given @p character is supported by the font.
*
* @return @e true if the character is supported by the font.
*/
- bool IsCharacterSupportedByFont( FontId fontId, Character character );
+ bool IsCharacterSupportedByFont(FontId fontId, Character character);
/**
* @brief Find the default font for displaying a UTF-32 character.
*
* @return A valid font identifier, or zero if the font does not exist.
*/
- FontId FindDefaultFont( Character charcode,
- PointSize26Dot6 requestedPointSize = DEFAULT_POINT_SIZE,
- bool preferColor = false );
+ FontId FindDefaultFont(Character charcode,
+ PointSize26Dot6 requestedPointSize = DEFAULT_POINT_SIZE,
+ bool preferColor = false);
/**
* @brief Find a fallback-font for displaying a UTF-32 character.
*
* @return A valid font identifier, or zero if the font does not exist.
*/
- FontId FindFallbackFont( Character charcode,
- const FontDescription& preferredFontDescription,
- PointSize26Dot6 requestedPointSize = DEFAULT_POINT_SIZE,
- bool preferColor = false );
+ FontId FindFallbackFont(Character charcode,
+ const FontDescription& preferredFontDescription,
+ PointSize26Dot6 requestedPointSize = DEFAULT_POINT_SIZE,
+ bool preferColor = false);
/**
* @brief Retrieve the unique identifier for a font.
*
* @return A valid font identifier, or zero if the font does not exist.
*/
- FontId GetFontId( const FontPath& path,
- PointSize26Dot6 requestedPointSize = DEFAULT_POINT_SIZE,
- FaceIndex faceIndex = 0 );
+ FontId GetFontId(const FontPath& path,
+ PointSize26Dot6 requestedPointSize = DEFAULT_POINT_SIZE,
+ FaceIndex faceIndex = 0);
/**
* @brief Retrieves a unique font identifier for a given description.
*
* @return A valid font identifier, or zero if no font is found.
*/
- FontId GetFontId( const FontDescription& preferredFontDescription,
- PointSize26Dot6 requestedPointSize = DEFAULT_POINT_SIZE,
- FaceIndex faceIndex = 0 );
+ FontId GetFontId(const FontDescription& preferredFontDescription,
+ PointSize26Dot6 requestedPointSize = DEFAULT_POINT_SIZE,
+ FaceIndex faceIndex = 0);
/**
* @brief Retrieves a unique font identifier for a given bitmap font.
*
* @return A valid font identifier, or zero if no bitmap font is created.
*/
- FontId GetFontId( const BitmapFont& bitmapFont );
+ FontId GetFontId(const BitmapFont& bitmapFont);
/**
* @brief Check to see if a font is scalable.
* @param[in] path The path to a font file.
* @return true if scalable.
*/
- bool IsScalable( const FontPath& path );
+ bool IsScalable(const FontPath& path);
/**
* @brief Check to see if a font is scalable.
*
* @return true if scalable
*/
- bool IsScalable( const FontDescription& fontDescription );
+ bool IsScalable(const FontDescription& fontDescription);
/**
* @brief Get a list of sizes available for a fixed size font.
* @param[in] path The path to a font file.
* @param[out] sizes A list of the available sizes, if no sizes available will return empty.
*/
- void GetFixedSizes( const FontPath& path, Dali::Vector< PointSize26Dot6>& sizes );
+ void GetFixedSizes(const FontPath& path, Dali::Vector<PointSize26Dot6>& sizes);
/**
* @brief Get a list of sizes available for a fixed size font.
* @param[in] fontDescription A font description.
* @param[out] sizes A list of the available sizes, if no sizes available will return empty.
*/
- void GetFixedSizes( const FontDescription& fontDescription,
- Dali::Vector< PointSize26Dot6 >& sizes );
+ void GetFixedSizes(const FontDescription& fontDescription,
+ Dali::Vector<PointSize26Dot6>& sizes);
/**
* @brief Whether the font has Italic style.
*
* @return true if the font has italic style.
*/
- bool HasItalicStyle( FontId fontId ) const;
+ bool HasItalicStyle(FontId fontId) const;
////////////////////////////////////////
// Font metrics, glyphs and bitmaps.
* @param[in] fontId The identifier of the font for the required glyph.
* @param[out] metrics The font metrics.
*/
- void GetFontMetrics( FontId fontId, FontMetrics& metrics );
+ void GetFontMetrics(FontId fontId, FontMetrics& metrics);
/**
* @brief Retrieve the glyph index for a UTF-32 character code.
*
* @return The glyph index, or zero if the character code is undefined.
*/
- GlyphIndex GetGlyphIndex( FontId fontId, Character charcode );
+ GlyphIndex GetGlyphIndex(FontId fontId, Character charcode);
/**
* @brief Retrieve the metrics for a series of glyphs.
*
* @return @e true if all of the requested metrics were found.
*/
- bool GetGlyphMetrics( GlyphInfo* array, uint32_t size, GlyphType type, bool horizontal = true );
+ bool GetGlyphMetrics(GlyphInfo* array, uint32_t size, GlyphType type, bool horizontal = true);
/**
* @brief Create a bitmap representation of a glyph.
* @param[out] data The bitmap data.
* @param[in] outlineWidth The width of the glyph outline in pixels.
*/
- void CreateBitmap( FontId fontId, GlyphIndex glyphIndex, bool isItalicRequired, bool isBoldRequired, GlyphBufferData& data, int outlineWidth );
+ void CreateBitmap(FontId fontId, GlyphIndex glyphIndex, bool isItalicRequired, bool isBoldRequired, GlyphBufferData& data, int outlineWidth);
/**
* @brief Create a bitmap representation of a glyph.
*
* @return A valid PixelData, or an empty handle if the glyph could not be rendered.
*/
- PixelData CreateBitmap( FontId fontId, GlyphIndex glyphIndex, int outlineWidth );
+ PixelData CreateBitmap(FontId fontId, GlyphIndex glyphIndex, int outlineWidth);
/**
* @brief Create a vector representation of a glyph.
* @param[out] nominalWidth The width of the blob.
* @param[out] nominalHeight The height of the blob.
*/
- void CreateVectorBlob( FontId fontId,
- GlyphIndex glyphIndex,
- VectorBlob*& blob,
- unsigned int& blobLength,
- unsigned int& nominalWidth,
- unsigned int& nominalHeight );
+ void CreateVectorBlob(FontId fontId,
+ GlyphIndex glyphIndex,
+ VectorBlob*& blob,
+ unsigned int& blobLength,
+ unsigned int& nominalWidth,
+ unsigned int& nominalHeight);
/**
* @brief Retrieves the ellipsis glyph for a requested point size.
*
* @return The ellipsis glyph.
*/
- const GlyphInfo& GetEllipsisGlyph( PointSize26Dot6 requestedPointSize );
+ const GlyphInfo& GetEllipsisGlyph(PointSize26Dot6 requestedPointSize);
/**
* @brief Whether the given glyph @p glyphIndex is a color glyph.
*
* @return @e true if the glyph is a color one.
*/
- bool IsColorGlyph( FontId fontId, GlyphIndex glyphIndex );
+ bool IsColorGlyph(FontId fontId, GlyphIndex glyphIndex);
/**
* @brief Add custom fonts directory
*
* @return true if the fonts can be added.
*/
- bool AddCustomFontDirectory( const FontPath& path );
+ bool AddCustomFontDirectory(const FontPath& path);
/**
* @brief Creates and stores an embedded item and it's metrics.
*
* return The index within the vector of embedded items.
*/
- GlyphIndex CreateEmbeddedItem( const EmbeddedItemDescription& description, Pixel::Format& pixelFormat);
-
+ GlyphIndex CreateEmbeddedItem(const EmbeddedItemDescription& description, Pixel::Format& pixelFormat);
public: // Not intended for application developers
/**
*
* @param[in] fontClient A pointer to the internal fontClient object.
*/
- explicit DALI_INTERNAL FontClient( Internal::FontClient* fontClient );
+ explicit DALI_INTERNAL FontClient(Internal::FontClient* fontClient);
};
/**
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace TextAbstraction
{
-
-DALI_ADAPTOR_API std::ostream& operator<<( std::ostream& o, const FontList& fontList )
+DALI_ADAPTOR_API std::ostream& operator<<(std::ostream& o, const FontList& fontList)
{
- for( unsigned int i=0; i<fontList.size(); ++i )
+ for(unsigned int i = 0; i < fontList.size(); ++i)
{
const FontDescription& description = fontList[i];
- o << "Font " << i << ") path: " << description.path << " family: " << " width : " << description.width << " weight : " << description.weight << " slant : " << description.slant << std::endl;
+ o << "Font " << i << ") path: " << description.path << " family: "
+ << " width : " << description.width << " weight : " << description.weight << " slant : " << description.slant << std::endl;
}
return o;
#define DALI_TEXT_ABSTRACTION_FONT_LIST_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
// EXTERNAL INCLUDES
-#include <string>
-#include <iostream>
#include <dali/public-api/common/vector-wrapper.h>
+#include <iostream>
+#include <string>
// INTERNAL INCLUDES
#include <dali/public-api/dali-adaptor-common.h>
namespace Dali
{
-
namespace TextAbstraction
{
typedef std::string FontPath;
namespace FontWidth
{
- /**
+/**
* @brief Enumeration type for the font's width
*/
- enum Type
- {
- NONE, ///< Means not defined. Will use what is set as default, currently NORMAL.
- ULTRA_CONDENSED,
- EXTRA_CONDENSED,
- CONDENSED,
- SEMI_CONDENSED,
- NORMAL,
- SEMI_EXPANDED,
- EXPANDED,
- EXTRA_EXPANDED,
- ULTRA_EXPANDED
- };
+enum Type
+{
+ NONE, ///< Means not defined. Will use what is set as default, currently NORMAL.
+ ULTRA_CONDENSED,
+ EXTRA_CONDENSED,
+ CONDENSED,
+ SEMI_CONDENSED,
+ NORMAL,
+ SEMI_EXPANDED,
+ EXPANDED,
+ EXTRA_EXPANDED,
+ ULTRA_EXPANDED
+};
- const char* const Name[] =
+const char* const Name[] =
{
"NONE",
"ULTRA_CONDENSED",
"SEMI_EXPANDED",
"EXPANDED",
"EXTRA_EXPANDED",
- "ULTRA_EXPANDED"
- };
+ "ULTRA_EXPANDED"};
} // namespace FontWidth
namespace FontWeight
{
- /**
+/**
* @brief Enumeration type for the font's weight
*/
- enum Type
- {
- NONE, ///< Means not defined. Will use what is set as default, currently NORMAL.
- THIN,
- ULTRA_LIGHT,
- EXTRA_LIGHT = ULTRA_LIGHT,
- LIGHT,
- DEMI_LIGHT,
- SEMI_LIGHT = DEMI_LIGHT,
- BOOK,
- NORMAL,
- REGULAR = NORMAL,
- MEDIUM,
- DEMI_BOLD,
- SEMI_BOLD = DEMI_BOLD,
- BOLD,
- ULTRA_BOLD,
- EXTRA_BOLD = ULTRA_BOLD,
- BLACK,
- HEAVY = BLACK,
- EXTRA_BLACK = BLACK
- };
+enum Type
+{
+ NONE, ///< Means not defined. Will use what is set as default, currently NORMAL.
+ THIN,
+ ULTRA_LIGHT,
+ EXTRA_LIGHT = ULTRA_LIGHT,
+ LIGHT,
+ DEMI_LIGHT,
+ SEMI_LIGHT = DEMI_LIGHT,
+ BOOK,
+ NORMAL,
+ REGULAR = NORMAL,
+ MEDIUM,
+ DEMI_BOLD,
+ SEMI_BOLD = DEMI_BOLD,
+ BOLD,
+ ULTRA_BOLD,
+ EXTRA_BOLD = ULTRA_BOLD,
+ BLACK,
+ HEAVY = BLACK,
+ EXTRA_BLACK = BLACK
+};
- const char* const Name[] =
+const char* const Name[] =
{
"NONE",
"THIN",
"DEMI_BOLD",
"BOLD",
"ULTRA_BOLD",
- "BLACK"
- };
-}
+ "BLACK"};
+} // namespace FontWeight
namespace FontSlant
{
- /**
+/**
* @brief Enumeration type for the font's slant
*/
- enum Type
- {
- NONE, ///< Means not defined. Will use what is set as default, currently NORMAL.
- NORMAL,
- ROMAN = NORMAL,
- ITALIC,
- OBLIQUE
- };
+enum Type
+{
+ NONE, ///< Means not defined. Will use what is set as default, currently NORMAL.
+ NORMAL,
+ ROMAN = NORMAL,
+ ITALIC,
+ OBLIQUE
+};
- const char* const Name[] =
+const char* const Name[] =
{
"NONE",
"NORMAL",
"ITALIC",
- "OBLIQUE"
- };
+ "OBLIQUE"};
} // namespace FontSlant
struct FontDescription
FontDescription()
: path(),
family(),
- width( FontWidth::NONE ),
- weight( FontWeight::NONE ),
- slant( FontSlant::NONE ),
- type( INVALID )
- {}
+ width(FontWidth::NONE),
+ weight(FontWeight::NONE),
+ slant(FontSlant::NONE),
+ type(INVALID)
+ {
+ }
~FontDescription()
- {}
+ {
+ }
FontPath path; ///< The font's file name path.
FontFamily family; ///< The font's family name.
typedef std::vector<FontDescription> FontList;
-DALI_ADAPTOR_API std::ostream& operator<<( std::ostream& o, const FontList& fontList );
+DALI_ADAPTOR_API std::ostream& operator<<(std::ostream& o, const FontList& fontList);
} // namespace TextAbstraction
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace TextAbstraction
{
-
FontMetrics::FontMetrics()
-: ascender{ 0.f },
- descender{ 0.f },
- height{ 0.f },
- underlinePosition{ 0.f },
- underlineThickness{ 0.f }
+: ascender{0.f},
+ descender{0.f},
+ height{0.f},
+ underlinePosition{0.f},
+ underlineThickness{0.f}
{
}
-FontMetrics::FontMetrics( float ascenderPixels,
- float descenderPixels,
- float heightPixels,
- float underlinePositionPixels,
- float underlineThicknessPixels )
-: ascender{ ascenderPixels },
- descender{ descenderPixels },
- height{ heightPixels },
- underlinePosition{ underlinePositionPixels },
- underlineThickness{ underlineThicknessPixels }
+FontMetrics::FontMetrics(float ascenderPixels,
+ float descenderPixels,
+ float heightPixels,
+ float underlinePositionPixels,
+ float underlineThicknessPixels)
+: ascender{ascenderPixels},
+ descender{descenderPixels},
+ height{heightPixels},
+ underlinePosition{underlinePositionPixels},
+ underlineThickness{underlineThicknessPixels}
{
}
#define DALI_TEXT_ABSTRACTION_FONT_METRICS_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace TextAbstraction
{
-
/**
* The metrics for a Font expressed in pixels.
*/
/**
* @brief Create the font metrics in pixels.
*/
- FontMetrics( float ascenderPixels,
- float descenderPixels,
- float heightPixels,
- float underlinePositionPixels,
- float underlineThicknessPixels );
-
- float ascender; ///< The ascender in pixels.
- float descender; ///< The descender in pixels.
- float height; ///< The height in pixels.
- float underlinePosition; ///< The underline position in pixels.
- float underlineThickness; ///< The vertical height of the underline in pixels.
+ FontMetrics(float ascenderPixels,
+ float descenderPixels,
+ float heightPixels,
+ float underlinePositionPixels,
+ float underlineThicknessPixels);
+
+ float ascender; ///< The ascender in pixels.
+ float descender; ///< The descender in pixels.
+ float height; ///< The height in pixels.
+ float underlinePosition; ///< The underline position in pixels.
+ float underlineThickness; ///< The vertical height of the underline in pixels.
};
-} // Dali
+} // namespace TextAbstraction
-} // TextAbstraction
+} // namespace Dali
#endif //DALI_TEXT_ABSTRACTION_FONT_METRICS_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace TextAbstraction
{
-
GlyphInfo::GlyphInfo()
-: fontId{ 0u },
- index{ 0u },
- width( 0.f ),
- height{ 0.f },
- xBearing{ 0.f },
- yBearing{ 0.f },
- advance{ 0.f },
- scaleFactor{ 0.f },
- isItalicRequired{ false },
- isBoldRequired{ false }
+: fontId{0u},
+ index{0u},
+ width(0.f),
+ height{0.f},
+ xBearing{0.f},
+ yBearing{0.f},
+ advance{0.f},
+ scaleFactor{0.f},
+ isItalicRequired{false},
+ isBoldRequired{false}
{
}
-GlyphInfo::GlyphInfo( FontId font, GlyphIndex i )
-: fontId{ font },
- index{ i },
- width( 0.f ),
- height{ 0.f },
- xBearing{ 0.f },
- yBearing{ 0.f },
- advance{ 0.f },
- scaleFactor{ 0.f },
- isItalicRequired{ false },
- isBoldRequired{ false }
+GlyphInfo::GlyphInfo(FontId font, GlyphIndex i)
+: fontId{font},
+ index{i},
+ width(0.f),
+ height{0.f},
+ xBearing{0.f},
+ yBearing{0.f},
+ advance{0.f},
+ scaleFactor{0.f},
+ isItalicRequired{false},
+ isBoldRequired{false}
{
}
#define DALI_TEXT_ABSTRACTION_GLYPH_INFO_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
// INTERNAL INCLUDES
-#include <dali/public-api/dali-adaptor-common.h>
#include <dali/devel-api/text-abstraction/text-abstraction-definitions.h>
+#include <dali/public-api/dali-adaptor-common.h>
namespace Dali
{
-
namespace TextAbstraction
{
-
/**
* The information describing a glyph (font ID, index, metrics)
* The metrics are in pixels.
/**
* @brief Creates the GlyphInfo without metrics.
*/
- GlyphInfo( FontId font, GlyphIndex i );
-
- FontId fontId; ///< Identifies the font containing the glyph
- GlyphIndex index; ///< Uniquely identifies a glyph for a given FontId
- float width; ///< The width of the glyph
- float height; ///< The height of the glyph
- float xBearing; ///< The distance from the cursor position to the leftmost border of the glyph
- float yBearing; ///< The distance from the baseline to the topmost border of the glyph
- float advance; ///< The distance to move the cursor for this glyph
- float scaleFactor; ///< The scaling applied (fixed-size fonts only)
- bool isItalicRequired:1; ///< Whether the italic style is required.
- bool isBoldRequired:1; ///< Whether the bold style is required.
+ GlyphInfo(FontId font, GlyphIndex i);
+
+ FontId fontId; ///< Identifies the font containing the glyph
+ GlyphIndex index; ///< Uniquely identifies a glyph for a given FontId
+ float width; ///< The width of the glyph
+ float height; ///< The height of the glyph
+ float xBearing; ///< The distance from the cursor position to the leftmost border of the glyph
+ float yBearing; ///< The distance from the baseline to the topmost border of the glyph
+ float advance; ///< The distance to move the cursor for this glyph
+ float scaleFactor; ///< The scaling applied (fixed-size fonts only)
+ bool isItalicRequired : 1; ///< Whether the italic style is required.
+ bool isBoldRequired : 1; ///< Whether the bold style is required.
};
-} // Dali
+} // namespace TextAbstraction
-} // TextAbstraction
+} // namespace Dali
#endif //DALI_TEXT_ABSTRACTION_GLYPH_INFO_H
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace TextAbstraction
{
-
namespace
{
-const unsigned int WHITE_SPACE_THRESHOLD = 0x21; ///< All characters below 0x21 are considered white spaces.
-const unsigned int CHAR_LF = 0x000A; ///< NL Line feed, new line.
-const unsigned int CHAR_VT = 0x000B; ///< Vertical tab.
-const unsigned int CHAR_FF = 0x000C; ///< NP Form feed, new page.
-const unsigned int CHAR_CR = 0x000D; ///< Carriage return, new line.
-const unsigned int CHAR_NEL = 0x0085; ///< Next line.
-const unsigned int CHAR_LS = 0x2028; ///< Line separator.
-const unsigned int CHAR_PS = 0x2029; ///< Paragraph separator
+const unsigned int WHITE_SPACE_THRESHOLD = 0x21; ///< All characters below 0x21 are considered white spaces.
+const unsigned int CHAR_LF = 0x000A; ///< NL Line feed, new line.
+const unsigned int CHAR_VT = 0x000B; ///< Vertical tab.
+const unsigned int CHAR_FF = 0x000C; ///< NP Form feed, new page.
+const unsigned int CHAR_CR = 0x000D; ///< Carriage return, new line.
+const unsigned int CHAR_NEL = 0x0085; ///< Next line.
+const unsigned int CHAR_LS = 0x2028; ///< Line separator.
+const unsigned int CHAR_PS = 0x2029; ///< Paragraph separator
const unsigned int CHAR_ZWS = 0x200B; ///< Zero width space.
const unsigned int CHAR_ZWNJ = 0x200C; ///< Zero width non joiner.
const unsigned int CHAR_TS = 0x2009; ///< Thin Space.
} // namespace
-bool IsRightToLeftScript( Script script )
+bool IsRightToLeftScript(Script script)
{
- return ( ( ARABIC == script ) ||
- ( HEBREW == script ) );
+ return ((ARABIC == script) ||
+ (HEBREW == script));
}
-Script GetCharacterScript( Character character )
+Script GetCharacterScript(Character character)
{
// Latin script: It contains punctuation characters and symbols which are not part of the latin script. https://en.wikipedia.org/wiki/Latin_script_in_Unicode
// 0x0000 - 0x007f C0 Controls and Basic Latin
// 0x25aa
// 0x262a
- if( IsCommonScript( character ) )
+ if(IsCommonScript(character))
{
return COMMON;
}
- if( character <= 0x0cff )
+ if(character <= 0x0cff)
{
- if( character <= 0x09ff )
+ if(character <= 0x09ff)
{
- if( character <= 0x077f )
+ if(character <= 0x077f)
{
- if( ( 0x0030 <= character ) && ( character <= 0x0039 ) )
+ if((0x0030 <= character) && (character <= 0x0039))
{
return ASCII_DIGITS;
}
- if( character <= 0x007E )
+ if(character <= 0x007E)
{
- if( ( 0x0020 <= character ) && ( character <= 0x002F ) )
+ if((0x0020 <= character) && (character <= 0x002F))
{
return ASCII_PS;
}
- if( ( 0x003A <= character ) && ( character <= 0x0040 ) )
+ if((0x003A <= character) && (character <= 0x0040))
{
return ASCII_PS;
}
- if( ( 0x005B <= character ) && ( character <= 0x0060 ) )
+ if((0x005B <= character) && (character <= 0x0060))
{
return ASCII_PS;
}
- if( ( 0x007B <= character ) && ( character <= 0x007E ) )
+ if((0x007B <= character) && (character <= 0x007E))
{
return ASCII_PS;
}
}
- if( ( 0x007F <= character ) && ( character <= 0x009F ) )
+ if((0x007F <= character) && (character <= 0x009F))
{
// 0x007F is actually part of C0 Controls and Basic Latin. However, is the last and only control character of its block
// and the following characters of the next block are consecutive.
return C1_CONTROLS;
}
- if( ( 0x00A0 <= character ) && ( character <= 0x00BF ) )
+ if((0x00A0 <= character) && (character <= 0x00BF))
{
- if( character == 0x00A9 )
+ if(character == 0x00A9)
{
return EMOJI; // 5. Uncategorized: copyright sign
}
- if( character == 0x00AE )
+ if(character == 0x00AE)
{
return EMOJI; // 5. Uncategorized: registered sign
}
return C1_PS;
}
- if( character == 0x00D7 )
+ if(character == 0x00D7)
{
return C1_MATH;
}
- if( character == 0x00F7 )
+ if(character == 0x00F7)
{
- return C1_MATH;
+ return C1_MATH;
}
- if( character <= 0x02ff )
+ if(character <= 0x02ff)
{
- if( ( 0x02B9 <= character ) && ( character <= 0x02BF ) )
+ if((0x02B9 <= character) && (character <= 0x02BF))
{
return SML_P;
}
return LATIN;
}
- if( ( 0x0370 <= character ) && ( character <= 0x03ff ) )
+ if((0x0370 <= character) && (character <= 0x03ff))
{
return GREEK;
}
- if( ( 0x0400 <= character ) && ( character <= 0x04ff ) )
+ if((0x0400 <= character) && (character <= 0x04ff))
{
return CYRILLIC;
}
- if( ( 0x0500 <= character ) && ( character <= 0x052f ) )
+ if((0x0500 <= character) && (character <= 0x052f))
{
return CYRILLIC;
}
- if( ( 0x0530 <= character ) && ( character <= 0x058f ) )
+ if((0x0530 <= character) && (character <= 0x058f))
{
return ARMENIAN;
}
- if( ( 0x0591 <= character ) && ( character <= 0x05f4 ) )
+ if((0x0591 <= character) && (character <= 0x05f4))
{
return HEBREW;
}
- if( ( 0x0600 <= character ) && ( character <= 0x06ff ) )
+ if((0x0600 <= character) && (character <= 0x06ff))
{
return ARABIC;
}
- if( ( 0x0750 <= character ) && ( character <= 0x077f ) )
+ if((0x0750 <= character) && (character <= 0x077f))
{
return ARABIC;
}
}
else // > 0x077f
{
- if( ( 0x08A0 <= character ) && ( character <= 0x08ff ) )
+ if((0x08A0 <= character) && (character <= 0x08ff))
{
return ARABIC;
}
- if( ( 0x0900 <= character ) && ( character <= 0x097f ) )
+ if((0x0900 <= character) && (character <= 0x097f))
{
return DEVANAGARI;
}
- if( ( 0x0980 <= character ) && ( character <= 0x09ff ) )
+ if((0x0980 <= character) && (character <= 0x09ff))
{
return BENGALI;
}
}
else // > 0x09ff
{
- if( character <= 0x0b7f )
+ if(character <= 0x0b7f)
{
- if( ( 0x0a00 <= character ) && ( character <= 0x0a7f ) )
+ if((0x0a00 <= character) && (character <= 0x0a7f))
{
return GURMUKHI;
}
- if( ( 0x0a80 <= character ) && ( character <= 0x0aff ) )
+ if((0x0a80 <= character) && (character <= 0x0aff))
{
return GUJARATI;
}
- if( ( 0x0b00 <= character ) && ( character <= 0x0b7f ) )
+ if((0x0b00 <= character) && (character <= 0x0b7f))
{
return ORIYA;
}
}
else // > 0x0b7f
{
- if( ( 0x0b80 <= character ) && ( character <= 0x0bff ) )
+ if((0x0b80 <= character) && (character <= 0x0bff))
{
return TAMIL;
}
- if( ( 0x0c00 <= character ) && ( character <= 0x0c7f ) )
+ if((0x0c00 <= character) && (character <= 0x0c7f))
{
return TELUGU;
}
- if( ( 0x0c80 <= character ) && ( character <= 0x0cff ) )
+ if((0x0c80 <= character) && (character <= 0x0cff))
{
return KANNADA;
}
}
else // > 0x0cff
{
- if( character <= 0x2c7f )
+ if(character <= 0x2c7f)
{
- if( character <= 0x1eff )
+ if(character <= 0x1eff)
{
- if( ( 0x0d00 <= character ) && ( character <= 0x0d7f ) )
+ if((0x0d00 <= character) && (character <= 0x0d7f))
{
return MALAYALAM;
}
- if( ( 0x0d80 <= character ) && ( character <= 0x0dff ) )
+ if((0x0d80 <= character) && (character <= 0x0dff))
{
return SINHALA;
}
- if( ( 0x0e00 <= character ) && ( character <= 0x0e7f ) )
+ if((0x0e00 <= character) && (character <= 0x0e7f))
{
return THAI;
}
- if( ( 0x0e80 <= character ) && ( character <= 0x0eff ) )
+ if((0x0e80 <= character) && (character <= 0x0eff))
{
return LAO;
}
- if( ( 0x1000 <= character ) && ( character <= 0x109f ) )
+ if((0x1000 <= character) && (character <= 0x109f))
{
return BURMESE;
}
- if( ( 0x10a0 <= character ) && ( character <= 0x10ff ) )
+ if((0x10a0 <= character) && (character <= 0x10ff))
{
return GEORGIAN;
}
- if( ( 0x1100 <= character ) && ( character <= 0x11ff ) )
+ if((0x1100 <= character) && (character <= 0x11ff))
{
return HANGUL;
}
- if( ( 0x1200 <= character ) && ( character <= 0x137f ) )
+ if((0x1200 <= character) && (character <= 0x137f))
{
return GEEZ;
}
- if( ( 0x1380 <= character ) && ( character <= 0x139f ) )
+ if((0x1380 <= character) && (character <= 0x139f))
{
return GEEZ;
}
- if( ( 0x1700 <= character ) && ( character <= 0x171f ) )
+ if((0x1700 <= character) && (character <= 0x171f))
{
return BAYBAYIN;
}
- if( ( 0x1780 <= character ) && ( character <= 0x17ff ) )
+ if((0x1780 <= character) && (character <= 0x17ff))
{
return KHMER;
}
- if( ( 0x19e0 <= character ) && ( character <= 0x19ff ) )
+ if((0x19e0 <= character) && (character <= 0x19ff))
{
return KHMER;
}
- if( ( 0x1b80 <= character ) && ( character <= 0x1bbf ) )
+ if((0x1b80 <= character) && (character <= 0x1bbf))
{
return SUNDANESE;
}
- if( ( 0x1c50 <= character ) && ( character <= 0x1c7f ) )
+ if((0x1c50 <= character) && (character <= 0x1c7f))
{
return OL_CHIKI;
}
- if( ( 0x1cc0 <= character ) && ( character <= 0x1ccf ) )
+ if((0x1cc0 <= character) && (character <= 0x1ccf))
{
return SUNDANESE;
}
- if( ( 0x1d00 <= character ) && ( character <= 0x1eff ) )
+ if((0x1d00 <= character) && (character <= 0x1eff))
{
- if( ( 0x1D26 <= character ) && ( character <= 0x1D2B ) )
+ if((0x1D26 <= character) && (character <= 0x1D2B))
{
return PHONETIC_U;
}
- if( ( 0x1D5D <= character ) && ( character <= 0x1D61 ) )
+ if((0x1D5D <= character) && (character <= 0x1D61))
{
return PHONETIC_SS;
}
- if( ( 0x1D66 <= character ) && ( character <= 0x1D6A ) )
+ if((0x1D66 <= character) && (character <= 0x1D6A))
{
return PHONETIC_SS;
}
- if( character == 0x1D78 )
+ if(character == 0x1D78)
{
return PHONETIC_SS;
}
- if( character == 0x1DBF)
+ if(character == 0x1DBF)
{
return PHONETIC_SS;
}
}
else // > 0x1eff
{
- if( ( 0x1f00 <= character ) && ( character <= 0x1fff ) )
+ if((0x1f00 <= character) && (character <= 0x1fff))
{
return GREEK;
}
- if( character == 0x203c )
+ if(character == 0x203c)
{
return EMOJI; // 5. Uncategorized: double exclamation mark
}
- if( character == 0x2049 )
+ if(character == 0x2049)
{
return EMOJI; // 5. Uncategorized: exclamation question mark
}
- if( ( 0x2070 <= character ) && ( character <= 0x209f ) )
+ if((0x2070 <= character) && (character <= 0x209f))
{
- if( character == 0x2070 )
+ if(character == 0x2070)
{
return NUMERIC_SS;
}
- if( ( 0x2074 <= character ) && ( character <= 0x207E ) )
+ if((0x2074 <= character) && (character <= 0x207E))
{
return NUMERIC_SS;
}
return LATIN;
}
- if( character == 0x20e3 )
+ if(character == 0x20e3)
{
return EMOJI; // 5. Uncategorized: combining enclosing keycap
}
- if( character == 0x2122 )
+ if(character == 0x2122)
{
return EMOJI; // 5. Uncategorized: trade mark sign
}
- if( character == 0x2139 )
+ if(character == 0x2139)
{
return EMOJI; // 5. Uncategorized: information source
}
- if( ( 0x2100 <= character ) && ( character <= 0x2189 ) )
+ if((0x2100 <= character) && (character <= 0x2189))
{
- if( ( 0x2100 <= character ) && ( character <= 0x214f ) )
+ if((0x2100 <= character) && (character <= 0x214f))
{
- if( ( 0x212A <= character ) && ( character <= 0x212B ) )
+ if((0x212A <= character) && (character <= 0x212B))
{
return LATIN;
}
- if( character == 0x2132 )
+ if(character == 0x2132)
{
return LATIN;
}
- if( character == 0x214E )
+ if(character == 0x214E)
{
return LATIN;
}
return LETTER_LIKE;
}
- if( ( 0x2150 <= character ) && ( character <= 0x215F ) )
+ if((0x2150 <= character) && (character <= 0x215F))
{
return FRACTIONS_NF;
}
- if( character == 0x2189 )
+ if(character == 0x2189)
{
return FRACTIONS_NF;
}
}
// Symbols
- if( ( 0x25cb == character ) ||
- ( 0x25cf == character ) ||
- ( 0x25a1 == character ) )
+ if((0x25cb == character) ||
+ (0x25cf == character) ||
+ (0x25a1 == character))
{
return SYMBOLS1;
}
- if( 0x25a0 == character )
+ if(0x25a0 == character)
{
return SYMBOLS2;
}
- if( ( 0x2664 == character ) ||
- ( 0x2661 == character ) ||
- ( 0x2662 == character ) ||
- ( 0x2667 == character ) )
+ if((0x2664 == character) ||
+ (0x2661 == character) ||
+ (0x2662 == character) ||
+ (0x2667 == character))
{
return SYMBOLS3;
}
- if( ( 0x2606 == character ) ||
- ( 0x25aa == character ) )
+ if((0x2606 == character) ||
+ (0x25aa == character))
{
return SYMBOLS4;
}
- if( 0x262a == character )
+ if(0x262a == character)
{
return SYMBOLS5;
}
// U+2194 5. Uncategorized: left right arrow
// U+2B55 5. Uncategorized: heavy large circle
- if( ( 0x2194 <= character ) && ( character <= 0x2B55 ) )
+ if((0x2194 <= character) && (character <= 0x2B55))
{
return EMOJI;
}
- if( ( 0x2c60 <= character ) && ( character <= 0x2c7f ) )
+ if((0x2c60 <= character) && (character <= 0x2c7f))
{
return LATIN;
}
}
else // > 0x2c7f
{
- if( character <= 0xfdff )
+ if(character <= 0xfdff)
{
- if( ( 0x2d00 <= character ) && ( character <= 0x2d2f ) )
+ if((0x2d00 <= character) && (character <= 0x2d2f))
{
return GEORGIAN;
}
- if( ( 0x2d80 <= character ) && ( character <= 0x2ddf ) )
+ if((0x2d80 <= character) && (character <= 0x2ddf))
{
return GEEZ;
}
- if( ( 0x2de0 <= character ) && ( character <= 0x2dff ) )
+ if((0x2de0 <= character) && (character <= 0x2dff))
{
return CYRILLIC;
}
- if( ( 0x2e80 <= character ) && ( character <= 0x2eff ) )
+ if((0x2e80 <= character) && (character <= 0x2eff))
{
return CJK;
}
- if( ( 0x2f00 <= character ) && ( character <= 0x2fdf ) )
+ if((0x2f00 <= character) && (character <= 0x2fdf))
{
return CJK;
}
- if( ( 0x3000 <= character ) && ( character <= 0x303f ) )
+ if((0x3000 <= character) && (character <= 0x303f))
{
return CJK;
}
- if( ( 0x3040 <= character ) && ( character <= 0x309f ) )
+ if((0x3040 <= character) && (character <= 0x309f))
{
return HIRAGANA;
}
- if( ( 0x30a0 <= character ) && ( character <= 0x30ff ) )
+ if((0x30a0 <= character) && (character <= 0x30ff))
{
return KATAKANA;
}
- if( ( 0x3100 <= character ) && ( character <= 0x312f ) )
+ if((0x3100 <= character) && (character <= 0x312f))
{
return BOPOMOFO;
}
- if( ( 0x3130 <= character ) && ( character <= 0x318f ) )
+ if((0x3130 <= character) && (character <= 0x318f))
{
return HANGUL;
}
- if( ( 0x31a0 <= character ) && ( character <= 0x31bf ) )
+ if((0x31a0 <= character) && (character <= 0x31bf))
{
return BOPOMOFO;
}
- if( ( 0x3200 <= character ) && ( character <= 0x32ff ) )
+ if((0x3200 <= character) && (character <= 0x32ff))
{
return CJK;
}
- if( ( 0x3400 <= character ) && ( character <= 0x4dbf ) )
+ if((0x3400 <= character) && (character <= 0x4dbf))
{
return CJK;
}
- if( ( 0x4e00 <= character ) && ( character <= 0x62ff ) )
+ if((0x4e00 <= character) && (character <= 0x62ff))
{
return CJK;
}
- if( ( 0x6300 <= character ) && ( character <= 0x77ff ) )
+ if((0x6300 <= character) && (character <= 0x77ff))
{
return CJK;
}
- if( ( 0x7800 <= character ) && ( character <= 0x8cff ) )
+ if((0x7800 <= character) && (character <= 0x8cff))
{
return CJK;
}
- if( ( 0x8d00 <= character ) && ( character <= 0x9fff ) )
+ if((0x8d00 <= character) && (character <= 0x9fff))
{
return CJK;
}
- if( ( 0xa640 <= character ) && ( character <= 0xa69f ) )
+ if((0xa640 <= character) && (character <= 0xa69f))
{
return CYRILLIC;
}
- if( ( 0xa720 <= character ) && ( character <= 0xa7ff ) )
+ if((0xa720 <= character) && (character <= 0xa7ff))
{
- if( character == 0xA720 )
+ if(character == 0xA720)
{
return PHONETIC_U;
}
- if( character == 0xA721 )
+ if(character == 0xA721)
{
return PHONETIC_U;
}
- if( character == 0xA788 )
+ if(character == 0xA788)
{
return NON_LATIN_LED;
}
- if( character == 0xA789 )
+ if(character == 0xA789)
{
return NON_LATIN_LED;
}
- if( character == 0xA78A )
+ if(character == 0xA78A)
{
return NON_LATIN_LED;
}
return LATIN;
}
- if( ( 0xa960 <= character ) && ( character <= 0xa97f ) )
+ if((0xa960 <= character) && (character <= 0xa97f))
{
return HANGUL;
}
- if( ( 0xa980 <= character ) && ( character <= 0xa9fd ) )
+ if((0xa980 <= character) && (character <= 0xa9fd))
{
return JAVANESE;
}
- if( ( 0xab00 <= character ) && ( character <= 0xab2f ) )
+ if((0xab00 <= character) && (character <= 0xab2f))
{
return GEEZ;
}
- if( ( 0xab30 <= character ) && ( character <= 0xab6f ) )
+ if((0xab30 <= character) && (character <= 0xab6f))
{
return LATIN;
}
- if( ( 0xaae0 <= character ) && ( character <= 0xaaff ) )
+ if((0xaae0 <= character) && (character <= 0xaaff))
{
return MEITEI;
}
- if( ( 0xabc0 <= character ) && ( character <= 0xabff ) )
+ if((0xabc0 <= character) && (character <= 0xabff))
{
return MEITEI;
}
- if( ( 0xac00 <= character ) && ( character <= 0xd7af ) )
+ if((0xac00 <= character) && (character <= 0xd7af))
{
return HANGUL;
}
- if( ( 0xd7b0 <= character ) && ( character <= 0xd7ff ) )
+ if((0xd7b0 <= character) && (character <= 0xd7ff))
{
return HANGUL;
}
- if( ( 0xfb00 <= character ) && ( character <= 0xfb06 ) )
+ if((0xfb00 <= character) && (character <= 0xfb06))
{
return LATIN;
}
- if( ( 0xfb13 <= character ) && ( character <= 0xfb17 ) )
+ if((0xfb13 <= character) && (character <= 0xfb17))
{
return ARMENIAN;
}
- if( ( 0xfb1d <= character ) && ( character <= 0xfb4f ) )
+ if((0xfb1d <= character) && (character <= 0xfb4f))
{
return HEBREW;
}
- if( ( 0xfb50 <= character ) && ( character <= 0xfdff ) )
+ if((0xfb50 <= character) && (character <= 0xfdff))
{
return ARABIC;
}
}
else // > 0xfdff
{
- if( ( 0xfe70 <= character ) && ( character <= 0xfeff ) )
+ if((0xfe70 <= character) && (character <= 0xfeff))
{
return ARABIC;
}
- if( ( 0xff00 <= character ) && ( character <= 0xffef ) )
+ if((0xff00 <= character) && (character <= 0xffef))
{
- if( ( 0xFF00 <= character ) && ( character <= 0xFF20 ) )
+ if((0xFF00 <= character) && (character <= 0xFF20))
{
return HWFW_S;
}
- if( ( 0xFF3B <= character ) && ( character <= 0xFF40 ) )
+ if((0xFF3B <= character) && (character <= 0xFF40))
{
return HWFW_S;
}
- if( ( 0xFF5B <= character ) && ( character <= 0xFFEF ) )
+ if((0xFF5B <= character) && (character <= 0xFFEF))
{
return HWFW_S;
}
return LATIN;
}
- if( ( 0x1ee00 <= character ) && ( character <= 0x1eeff ) )
+ if((0x1ee00 <= character) && (character <= 0x1eeff))
{
return ARABIC;
}
// U+1f170 4. Enclosed characters: negative squared latin capital letter A
// U+1f6ff 6b. Additional transport and map symbols
- if( ( 0x1f170 <= character ) && ( character <= 0x1f6ff ) )
+ if((0x1f170 <= character) && (character <= 0x1f6ff))
{
return EMOJI;
}
// 7. Supplemental Symbols and Pictographs
- if( ( 0x1f900 <= character ) && ( character <= 0x1f9ff ) )
+ if((0x1f900 <= character) && (character <= 0x1f9ff))
{
return EMOJI;
}
- if( ( 0x20000 <= character ) && ( character <= 0x215ff ) )
+ if((0x20000 <= character) && (character <= 0x215ff))
{
return CJK;
}
- if( ( 0x21600 <= character ) && ( character <= 0x230ff ) )
+ if((0x21600 <= character) && (character <= 0x230ff))
{
return CJK;
}
- if( ( 0x23100 <= character ) && ( character <= 0x245ff ) )
+ if((0x23100 <= character) && (character <= 0x245ff))
{
return CJK;
}
- if( ( 0x24600 <= character ) && ( character <= 0x260ff ) )
+ if((0x24600 <= character) && (character <= 0x260ff))
{
return CJK;
}
- if( ( 0x26100 <= character ) && ( character <= 0x275ff ) )
+ if((0x26100 <= character) && (character <= 0x275ff))
{
return CJK;
}
- if( ( 0x27600 <= character ) && ( character <= 0x290ff ) )
+ if((0x27600 <= character) && (character <= 0x290ff))
{
return CJK;
}
- if( ( 0x29100 <= character ) && ( character <= 0x2a6df ) )
+ if((0x29100 <= character) && (character <= 0x2a6df))
{
return CJK;
}
- if( ( 0x2a700 <= character ) && ( character <= 0x2b73f ) )
+ if((0x2a700 <= character) && (character <= 0x2b73f))
{
return CJK;
}
- if( ( 0x2b740 <= character ) && ( character <= 0x2b81f ) )
+ if((0x2b740 <= character) && (character <= 0x2b81f))
{
return CJK;
}
return UNKNOWN;
}
-bool IsWhiteSpace( Character character )
+bool IsWhiteSpace(Character character)
{
return character < WHITE_SPACE_THRESHOLD;
}
-bool IsNewParagraph( Character character )
+bool IsNewParagraph(Character character)
{
- return ( ( CHAR_LF == character ) ||
- ( CHAR_VT == character ) ||
- ( CHAR_FF == character ) ||
- ( CHAR_CR == character ) ||
- ( CHAR_NEL == character ) ||
- ( CHAR_LS == character ) ||
- ( CHAR_PS == character ) );
+ return ((CHAR_LF == character) ||
+ (CHAR_VT == character) ||
+ (CHAR_FF == character) ||
+ (CHAR_CR == character) ||
+ (CHAR_NEL == character) ||
+ (CHAR_LS == character) ||
+ (CHAR_PS == character));
}
-bool IsZeroWidthNonJoiner( Character character )
+bool IsZeroWidthNonJoiner(Character character)
{
return CHAR_ZWNJ == character;
}
-bool IsZeroWidthJoiner( Character character )
+bool IsZeroWidthJoiner(Character character)
{
return CHAR_ZWJ == character;
}
-bool IsZeroWidthSpace( Character character )
+bool IsZeroWidthSpace(Character character)
{
return CHAR_ZWS == character;
}
-bool IsLeftToRightMark( Character character )
+bool IsLeftToRightMark(Character character)
{
return CHAR_LTRM == character;
}
-bool IsRightToLeftMark( Character character )
+bool IsRightToLeftMark(Character character)
{
return CHAR_RTLM == character;
}
-bool IsThinSpace( Character character )
+bool IsThinSpace(Character character)
{
return CHAR_TS == character;
}
-bool IsCommonScript( Character character )
+bool IsCommonScript(Character character)
{
- return ( IsWhiteSpace( character ) ||
- IsZeroWidthNonJoiner( character ) ||
- IsZeroWidthJoiner( character ) ||
- IsZeroWidthSpace( character ) ||
- IsLeftToRightMark( character ) ||
- IsRightToLeftMark( character ) ||
- IsThinSpace( character ) ||
- IsNewParagraph( character ) );
+ return (IsWhiteSpace(character) ||
+ IsZeroWidthNonJoiner(character) ||
+ IsZeroWidthJoiner(character) ||
+ IsZeroWidthSpace(character) ||
+ IsLeftToRightMark(character) ||
+ IsRightToLeftMark(character) ||
+ IsThinSpace(character) ||
+ IsNewParagraph(character));
}
-bool HasLigatureMustBreak( Script script )
+bool HasLigatureMustBreak(Script script)
{
- return ( ( LATIN == script ) ||
- ( ARABIC == script ) );
+ return ((LATIN == script) ||
+ (ARABIC == script));
}
} // namespace TextAbstraction
#define DALI_TOOLKIT_TEXT_ABSTRACTION_SCRIPT_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
// INTERNAL INCLUDES
-#include <dali/public-api/dali-adaptor-common.h>
#include <dali/devel-api/text-abstraction/text-abstraction-definitions.h>
+#include <dali/public-api/dali-adaptor-common.h>
namespace Dali
{
-
namespace TextAbstraction
{
-
/**
* @brief Script is the writing system used by a language.
* Typically one script can be used to write different languages although one language could be written in different scrips.
*/
enum Script
{
- COMMON, ///< Valid for all scripts. i.e white space or '\n'.
+ COMMON, ///< Valid for all scripts. i.e white space or '\n'.
- ASCII_DIGITS, ///< ASCII digits.
- ASCII_PS, ///< ASCII punctuation and symbols.
+ ASCII_DIGITS, ///< ASCII digits.
+ ASCII_PS, ///< ASCII punctuation and symbols.
- C1_CONTROLS, ///< Controls of the C1 Controls and Latin-1 Supplement unicode block.
- C1_PS, ///< Punctuation and symbols of the C1 Controls and Latin-1 Supplement unicode block.
- C1_MATH, ///< Math symbols of the C1 Controls and Latin-1 Supplement unicode block.
+ C1_CONTROLS, ///< Controls of the C1 Controls and Latin-1 Supplement unicode block.
+ C1_PS, ///< Punctuation and symbols of the C1 Controls and Latin-1 Supplement unicode block.
+ C1_MATH, ///< Math symbols of the C1 Controls and Latin-1 Supplement unicode block.
- SML_P, ///< Punctuation symbols of the Spacing Modifier Letters unicode block.
- PHONETIC_U, ///< Uralic phonetic symbols of the Phonetic Extensions unicode block.
- PHONETIC_SS, ///< Subscripts and superscripts of the Phonetic Extensions unicode block.
+ SML_P, ///< Punctuation symbols of the Spacing Modifier Letters unicode block.
+ PHONETIC_U, ///< Uralic phonetic symbols of the Phonetic Extensions unicode block.
+ PHONETIC_SS, ///< Subscripts and superscripts of the Phonetic Extensions unicode block.
- NUMERIC_SS, ///< Numeric subscripts and superscripts.
+ NUMERIC_SS, ///< Numeric subscripts and superscripts.
LETTER_LIKE, ///< Symbols of the Letterlike unicode block.
NUMBER_FORMS, ///< Number Forms unicode block.
NON_LATIN_LED, ///< Non latin symbols within the Latin Extended D unicode block.
HWFW_S, ///< Non latin symbols within the Halfwidth and fullwidth unicode block.
- CYRILLIC, ///< The Cyrillic script. Used by Russian, Bulgarian, Ukrainian, Macedonian, ...
- GREEK, ///< The Greek script. Used by Greek.
- LATIN, ///< The latin script. Used by many western languages and others around the world.
-
- ARABIC, ///< The arabic script. Used by Arab and Urdu among others.
- HEBREW, ///< The Hebrew script. Used by the Hebrew, Yiddish, Ladino, and Judeo-Arabic.
-
- ARMENIAN, ///< The Armenian script. Used by Armenian.
- GEORGIAN, ///< The Georgian script. Used by Georgian.
-
- CJK, ///< The CJK script. Used by Chinese, Japanese, Korean and Vietnamese(old writing system).
- HANGUL, ///< The Hangul jamo script. Used by Korean.
- HIRAGANA, ///< The Hiragana script. Used by the Japanese.
- KATAKANA, ///< The Katakana script. Used by the Japanese.
- BOPOMOFO, ///< The Bopomofo script. Also called Zhuyin fuhao or Zhuyin. A phonetic notation used for the transcription of spoken Chinese.
-
- BENGALI, ///< The Bengali script. Used by Bangla, Assamese, Bishnupriya Manipuri, Daphla, Garo, Hallam, Khasi, Mizo, Munda, Naga, Rian, and Santali.
- BURMESE, ///< The Burmese script. Used by the Burmese (Myanmar) language.
- DEVANAGARI, ///< The devanagari script. Used by Hindi, Marathi, Sindhi, Nepali and Sanskrit.
- GUJARATI, ///< The Gujarati script. Used by Gujarati.
- GURMUKHI, ///< The Gurmukhi script. Used by Punjabi.
- KANNADA, ///< The Kannada script. Used by Kannada and Tulu.
- MALAYALAM, ///< The Malayalam script. Used by Malayalam.
- ORIYA, ///< The Oriya script. Used by Oriya (Odia), Khondi, and Santali.
- SINHALA, ///< The Sinhala script. Used by Sinhala and Pali.
- TAMIL, ///< The Tamil script. Used by Tamil, Badaga, and Saurashtra.
- TELUGU, ///< The Telugu script. Used by Telugu, Gondi, and Lambadi.
-
- LAO, ///< The Lao script. Used by the Lao language.
- THAI, ///< The Thai script. Used by the Thai language
- KHMER, ///< The Khmer script. Used by the Khmer language.
- JAVANESE, ///< The Javanese script. Used by the Javanese language.
- SUNDANESE, ///< The Sundanese script. Used by the Sundanese language.
-
- GEEZ, ///< The Ge'ez script. Used by the Amharic, Tigrinya and other languages in Ethiopia and Eritrea.
- OL_CHIKI, ///< The Ol Chiki script. Used by the Santali.
- BAYBAYIN, ///< The Baybayin script. Used by the Tagalog, Bikol languages, Ilocano, Pangasinan, Visayan and other languages in Philippines.
- MEITEI, ///< The Meitei script used for the Meitei language in Manipur, India.
-
- EMOJI, ///< The Emoji which map to standardized Unicode characters.
-
- SYMBOLS1, ///< Some symbols.
- SYMBOLS2, ///< Some symbols.
- SYMBOLS3, ///< Some symbols.
- SYMBOLS4, ///< Some symbols.
- SYMBOLS5, ///< Some symbols.
-
- UNKNOWN ///< The script is unknown.
+ CYRILLIC, ///< The Cyrillic script. Used by Russian, Bulgarian, Ukrainian, Macedonian, ...
+ GREEK, ///< The Greek script. Used by Greek.
+ LATIN, ///< The latin script. Used by many western languages and others around the world.
+
+ ARABIC, ///< The arabic script. Used by Arab and Urdu among others.
+ HEBREW, ///< The Hebrew script. Used by the Hebrew, Yiddish, Ladino, and Judeo-Arabic.
+
+ ARMENIAN, ///< The Armenian script. Used by Armenian.
+ GEORGIAN, ///< The Georgian script. Used by Georgian.
+
+ CJK, ///< The CJK script. Used by Chinese, Japanese, Korean and Vietnamese(old writing system).
+ HANGUL, ///< The Hangul jamo script. Used by Korean.
+ HIRAGANA, ///< The Hiragana script. Used by the Japanese.
+ KATAKANA, ///< The Katakana script. Used by the Japanese.
+ BOPOMOFO, ///< The Bopomofo script. Also called Zhuyin fuhao or Zhuyin. A phonetic notation used for the transcription of spoken Chinese.
+
+ BENGALI, ///< The Bengali script. Used by Bangla, Assamese, Bishnupriya Manipuri, Daphla, Garo, Hallam, Khasi, Mizo, Munda, Naga, Rian, and Santali.
+ BURMESE, ///< The Burmese script. Used by the Burmese (Myanmar) language.
+ DEVANAGARI, ///< The devanagari script. Used by Hindi, Marathi, Sindhi, Nepali and Sanskrit.
+ GUJARATI, ///< The Gujarati script. Used by Gujarati.
+ GURMUKHI, ///< The Gurmukhi script. Used by Punjabi.
+ KANNADA, ///< The Kannada script. Used by Kannada and Tulu.
+ MALAYALAM, ///< The Malayalam script. Used by Malayalam.
+ ORIYA, ///< The Oriya script. Used by Oriya (Odia), Khondi, and Santali.
+ SINHALA, ///< The Sinhala script. Used by Sinhala and Pali.
+ TAMIL, ///< The Tamil script. Used by Tamil, Badaga, and Saurashtra.
+ TELUGU, ///< The Telugu script. Used by Telugu, Gondi, and Lambadi.
+
+ LAO, ///< The Lao script. Used by the Lao language.
+ THAI, ///< The Thai script. Used by the Thai language
+ KHMER, ///< The Khmer script. Used by the Khmer language.
+ JAVANESE, ///< The Javanese script. Used by the Javanese language.
+ SUNDANESE, ///< The Sundanese script. Used by the Sundanese language.
+
+ GEEZ, ///< The Ge'ez script. Used by the Amharic, Tigrinya and other languages in Ethiopia and Eritrea.
+ OL_CHIKI, ///< The Ol Chiki script. Used by the Santali.
+ BAYBAYIN, ///< The Baybayin script. Used by the Tagalog, Bikol languages, Ilocano, Pangasinan, Visayan and other languages in Philippines.
+ MEITEI, ///< The Meitei script used for the Meitei language in Manipur, India.
+
+ EMOJI, ///< The Emoji which map to standardized Unicode characters.
+
+ SYMBOLS1, ///< Some symbols.
+ SYMBOLS2, ///< Some symbols.
+ SYMBOLS3, ///< Some symbols.
+ SYMBOLS4, ///< Some symbols.
+ SYMBOLS5, ///< Some symbols.
+
+ UNKNOWN ///< The script is unknown.
};
const char* const ScriptName[] =
-{
- "COMMON", ///< Valid for all scripts. i.e white space or '\n'.
-
- "ASCII_DIGITS", ///< ASCII digits.
- "ASCII_PS", ///< ASCII punctuation and symbols.
-
- "C1_CONTROLS", ///< Controls of the C1 Controls and Latin-1 Supplement unicode block.
- "C1_PS", ///< Punctuation and symbols of the C1 Controls and Latin-1 Supplement unicode block.
- "C1_MATH", ///< Math symbols of the C1 Controls and Latin-1 Supplement unicode block.
-
- "SML_P", ///< Punctuation symbols of the Spacing Modifier Letters unicode block.
- "PHONETIC_U", ///< Uralic phonetic symbols of the Phonetic Extensions unicode block.
- "PHONETIC_SS", ///< Subscripts and superscripts of the Phonetic Extensions unicode block.
-
- "NUMERIC_SS", ///< Numeric subscripts and superscripts.
-
- "LETTER_LIKE", ///< Symbols of the Letterlike unicode block.
- "NUMBER_FORMS", ///< Number Forms unicode block.
- "FRACTIONS_NF", ///< Numeric fraction symbols of the Number Forms unicode block.
- "NON_LATIN_LED", ///< Non latin symbols within the Latin Extended D unicode block.
- "HWFW_S", ///< Non latin symbols within the Halfwidth and fullwidth unicode block.
-
- "CYRILLIC", ///< The Cyrillic script. Used by Russian, Bulgarian, Ukrainian, Macedonian, ...
- "GREEK", ///< The Greek script. Used by Greek.
- "LATIN", ///< The latin script. Used by many western languages and others around the world.
-
- "ARABIC", ///< The arabic script. Used by Arab and Urdu among others.
- "HEBREW", ///< The Hebrew script. Used by the Hebrew, Yiddish, Ladino, and Judeo-Arabic.
-
- "ARMENIAN", ///< The Armenian script. Used by Armenian.
- "GEORGIAN", ///< The Georgian script. Used by Georgian.
-
- "CJK", ///< The CJK script. Used by Chinese, Japanese, Korean and Vietnamese(old writing system).
- "HANGUL", ///< The Hangul jamo script. Used by Korean.
- "HIRAGANA", ///< The Hiragana script. Used by the Japanese.
- "KATAKANA", ///< The Katakana script. Used by the Japanese.
- "BOPOMOFO", ///< The Bopomofo script. Also called Zhuyin fuhao or Zhuyin. A phonetic notation used for the transcription of spoken Chinese.
-
- "BENGALI", ///< The Bengali script. Used by Bangla, Assamese, Bishnupriya Manipuri, Daphla, Garo, Hallam, Khasi, Mizo, Munda, Naga, Rian, and Santali.
- "BURMESE", ///< The Burmese script. Used by the Burmese (Myanmar) language.
- "DEVANAGARI", ///< The devanagari script. Used by Hindi, Marathi, Sindhi, Nepali and Sanskrit.
- "GUJARATI", ///< The Gujarati script. Used by Gujarati.
- "GURMUKHI", ///< The Gurmukhi script. Used by Punjabi.
- "KANNADA", ///< The Kannada script. Used by Kannada and Tulu.
- "MALAYALAM", ///< The Malayalam script. Used by Malayalam.
- "ORIYA", ///< The Oriya script. Used by Oriya (Odia), Khondi, and Santali.
- "SINHALA", ///< The Sinhala script. Used by Sinhala and Pali.
- "TAMIL", ///< The Tamil script. Used by Tamil, Badaga, and Saurashtra.
- "TELUGU", ///< The Telugu script. Used by Telugu, Gondi, and Lambadi.
-
- "LAO", ///< The Lao script. Used by the Lao language.
- "THAI", ///< The Thai script. Used by the Thai language
- "KHMER", ///< The Khmer script. Used by the Khmer language.
- "JAVANESE", ///< The Javanese script. Used by the Javanese language.
- "SUNDANESE", ///< The Sundanese script. Used by the Sundanese language.
-
- "GEEZ", ///< The Ge'ez script also known as Ethiopic. Used by the Amharic, Tigrinya and other languages in Ethiopia and Eritrea.
- "OL_CHIKI", ///< The Ol Chiki script. Used by the Santali.
- "BAYBAYIN", ///< The Baybayin script. Used by the Tagalog, Bikol languages, Ilocano, Pangasinan, Visayan and other languages in Philippines.
- "MEITEI", ///< The Meitei script used for the Meitei language in Manipur, India.
-
- "EMOJI", ///< The Emoji which map to standardized Unicode characters.
-
- "SYMBOLS1", ///< Some symbols.
- "SYMBOLS2", ///< Some symbols.
- "SYMBOLS3", ///< Some symbols.
- "SYMBOLS4", ///< Some symbols.
- "SYMBOLS5", ///< Some symbols.
-
- "UNKNOWN" ///< The script is unknown.
+ {
+ "COMMON", ///< Valid for all scripts. i.e white space or '\n'.
+
+ "ASCII_DIGITS", ///< ASCII digits.
+ "ASCII_PS", ///< ASCII punctuation and symbols.
+
+ "C1_CONTROLS", ///< Controls of the C1 Controls and Latin-1 Supplement unicode block.
+ "C1_PS", ///< Punctuation and symbols of the C1 Controls and Latin-1 Supplement unicode block.
+ "C1_MATH", ///< Math symbols of the C1 Controls and Latin-1 Supplement unicode block.
+
+ "SML_P", ///< Punctuation symbols of the Spacing Modifier Letters unicode block.
+ "PHONETIC_U", ///< Uralic phonetic symbols of the Phonetic Extensions unicode block.
+ "PHONETIC_SS", ///< Subscripts and superscripts of the Phonetic Extensions unicode block.
+
+ "NUMERIC_SS", ///< Numeric subscripts and superscripts.
+
+ "LETTER_LIKE", ///< Symbols of the Letterlike unicode block.
+ "NUMBER_FORMS", ///< Number Forms unicode block.
+ "FRACTIONS_NF", ///< Numeric fraction symbols of the Number Forms unicode block.
+ "NON_LATIN_LED", ///< Non latin symbols within the Latin Extended D unicode block.
+ "HWFW_S", ///< Non latin symbols within the Halfwidth and fullwidth unicode block.
+
+ "CYRILLIC", ///< The Cyrillic script. Used by Russian, Bulgarian, Ukrainian, Macedonian, ...
+ "GREEK", ///< The Greek script. Used by Greek.
+ "LATIN", ///< The latin script. Used by many western languages and others around the world.
+
+ "ARABIC", ///< The arabic script. Used by Arab and Urdu among others.
+ "HEBREW", ///< The Hebrew script. Used by the Hebrew, Yiddish, Ladino, and Judeo-Arabic.
+
+ "ARMENIAN", ///< The Armenian script. Used by Armenian.
+ "GEORGIAN", ///< The Georgian script. Used by Georgian.
+
+ "CJK", ///< The CJK script. Used by Chinese, Japanese, Korean and Vietnamese(old writing system).
+ "HANGUL", ///< The Hangul jamo script. Used by Korean.
+ "HIRAGANA", ///< The Hiragana script. Used by the Japanese.
+ "KATAKANA", ///< The Katakana script. Used by the Japanese.
+ "BOPOMOFO", ///< The Bopomofo script. Also called Zhuyin fuhao or Zhuyin. A phonetic notation used for the transcription of spoken Chinese.
+
+ "BENGALI", ///< The Bengali script. Used by Bangla, Assamese, Bishnupriya Manipuri, Daphla, Garo, Hallam, Khasi, Mizo, Munda, Naga, Rian, and Santali.
+ "BURMESE", ///< The Burmese script. Used by the Burmese (Myanmar) language.
+ "DEVANAGARI", ///< The devanagari script. Used by Hindi, Marathi, Sindhi, Nepali and Sanskrit.
+ "GUJARATI", ///< The Gujarati script. Used by Gujarati.
+ "GURMUKHI", ///< The Gurmukhi script. Used by Punjabi.
+ "KANNADA", ///< The Kannada script. Used by Kannada and Tulu.
+ "MALAYALAM", ///< The Malayalam script. Used by Malayalam.
+ "ORIYA", ///< The Oriya script. Used by Oriya (Odia), Khondi, and Santali.
+ "SINHALA", ///< The Sinhala script. Used by Sinhala and Pali.
+ "TAMIL", ///< The Tamil script. Used by Tamil, Badaga, and Saurashtra.
+ "TELUGU", ///< The Telugu script. Used by Telugu, Gondi, and Lambadi.
+
+ "LAO", ///< The Lao script. Used by the Lao language.
+ "THAI", ///< The Thai script. Used by the Thai language
+ "KHMER", ///< The Khmer script. Used by the Khmer language.
+ "JAVANESE", ///< The Javanese script. Used by the Javanese language.
+ "SUNDANESE", ///< The Sundanese script. Used by the Sundanese language.
+
+ "GEEZ", ///< The Ge'ez script also known as Ethiopic. Used by the Amharic, Tigrinya and other languages in Ethiopia and Eritrea.
+ "OL_CHIKI", ///< The Ol Chiki script. Used by the Santali.
+ "BAYBAYIN", ///< The Baybayin script. Used by the Tagalog, Bikol languages, Ilocano, Pangasinan, Visayan and other languages in Philippines.
+ "MEITEI", ///< The Meitei script used for the Meitei language in Manipur, India.
+
+ "EMOJI", ///< The Emoji which map to standardized Unicode characters.
+
+ "SYMBOLS1", ///< Some symbols.
+ "SYMBOLS2", ///< Some symbols.
+ "SYMBOLS3", ///< Some symbols.
+ "SYMBOLS4", ///< Some symbols.
+ "SYMBOLS5", ///< Some symbols.
+
+ "UNKNOWN" ///< The script is unknown.
};
/**
*
* @return @e true if the script is right to left.
*/
-DALI_ADAPTOR_API bool IsRightToLeftScript( Script script );
+DALI_ADAPTOR_API bool IsRightToLeftScript(Script script);
/**
* @brief Retrieves a character's script.
*
* @return The chraracter's script.
*/
-DALI_ADAPTOR_API Script GetCharacterScript( Character character );
+DALI_ADAPTOR_API Script GetCharacterScript(Character character);
/**
* @brief Whether the character is a white space.
*
* @return @e true if the character is a white space.
*/
-DALI_ADAPTOR_API bool IsWhiteSpace( Character character );
+DALI_ADAPTOR_API bool IsWhiteSpace(Character character);
/**
* @brief Whether the character is a new paragraph character.
*
* @return @e true if the character is a new paragraph character.
*/
-DALI_ADAPTOR_API bool IsNewParagraph( Character character );
+DALI_ADAPTOR_API bool IsNewParagraph(Character character);
/**
* @brief Whether the character is a zero width non joiner.
*
* @return @e true if the character is a zero width non joiner.
*/
-DALI_ADAPTOR_API bool IsZeroWidthNonJoiner( Character character );
+DALI_ADAPTOR_API bool IsZeroWidthNonJoiner(Character character);
/**
* @brief Whether the character is a zero width joiner.
*
* @return @e true if the character is a zero width joiner.
*/
-DALI_ADAPTOR_API bool IsZeroWidthJoiner( Character character );
+DALI_ADAPTOR_API bool IsZeroWidthJoiner(Character character);
/**
* @brief Whether the character is a zero width space.
*
* @return @e true if the character is a zero width space.
*/
-DALI_ADAPTOR_API bool IsZeroWidthSpace( Character character );
+DALI_ADAPTOR_API bool IsZeroWidthSpace(Character character);
/**
* @brief Whether the character is a left to right mark.
*
* @return @e true if the character is a left to right mark.
*/
-DALI_ADAPTOR_API bool IsLeftToRightMark( Character character );
+DALI_ADAPTOR_API bool IsLeftToRightMark(Character character);
/**
* @brief Whether the character is a right to left mark.
*
* @return @e true if the character is a right to left mark.
*/
-DALI_ADAPTOR_API bool IsRightToLeftMark( Character character );
+DALI_ADAPTOR_API bool IsRightToLeftMark(Character character);
/**
* @brief Whether the character is a thin space.
*
* @return @e true if the character is a thin space.
*/
-DALI_ADAPTOR_API bool IsThinSpace( Character character );
+DALI_ADAPTOR_API bool IsThinSpace(Character character);
/**
* @brief Whether the character is common within all scripts.
*
* @return @e true if the character is common within all scripts.
*/
-DALI_ADAPTOR_API bool IsCommonScript( Character character );
+DALI_ADAPTOR_API bool IsCommonScript(Character character);
/**
* @brief Whether the script contains ligatures that must be 'broken' for selection or cursor position.
*
* @return @e true if the script has ligatures that must be 'broken'.
*/
-DALI_ADAPTOR_API bool HasLigatureMustBreak( Script script );
+DALI_ADAPTOR_API bool HasLigatureMustBreak(Script script);
} // namespace TextAbstraction
} // namespace Dali
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace TextAbstraction
{
-
Segmentation::Segmentation()
{
}
{
}
-Segmentation::Segmentation( Internal::Segmentation* implementation )
-: BaseHandle( implementation )
+Segmentation::Segmentation(Internal::Segmentation* implementation)
+: BaseHandle(implementation)
{
}
return Internal::Segmentation::Get();
}
-void Segmentation::GetLineBreakPositions( const Character* const text,
- Length numberOfCharacters,
- LineBreakInfo* breakInfo )
+void Segmentation::GetLineBreakPositions(const Character* const text,
+ Length numberOfCharacters,
+ LineBreakInfo* breakInfo)
{
- GetImplementation( *this ).GetLineBreakPositions( text,
- numberOfCharacters,
- breakInfo );
+ GetImplementation(*this).GetLineBreakPositions(text,
+ numberOfCharacters,
+ breakInfo);
}
-void Segmentation::GetWordBreakPositions( const Character* const text,
- Length numberOfCharacters,
- WordBreakInfo* breakInfo )
+void Segmentation::GetWordBreakPositions(const Character* const text,
+ Length numberOfCharacters,
+ WordBreakInfo* breakInfo)
{
- GetImplementation( *this ).GetWordBreakPositions( text,
- numberOfCharacters,
- breakInfo );
+ GetImplementation(*this).GetWordBreakPositions(text,
+ numberOfCharacters,
+ breakInfo);
}
} // namespace TextAbstraction
#define DALI_PLATFORM_TEXT_ABSTRACTION_SEGMENTATION_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace TextAbstraction
{
-
namespace Internal DALI_INTERNAL
{
-
class Segmentation;
-} // Internal
+} // namespace DALI_INTERNAL
-} // TextAbstraction
+} // namespace TextAbstraction
namespace TextAbstraction
{
-
/**
* Segmentation API
*
*/
class DALI_ADAPTOR_API Segmentation : public BaseHandle
{
-
public:
-
/**
* @brief Create an uninitialized TextAbstraction handle.
*
*
* @param[in] implementation A pointer to the internal segmentation object.
*/
- explicit DALI_INTERNAL Segmentation( Internal::Segmentation* implementation );
+ explicit DALI_INTERNAL Segmentation(Internal::Segmentation* implementation);
/**
* @brief Retrieve a handle to the Segmentation instance.
* @param[in] numberOfCharacters The number of characters.
* @param[out] breakInfo The line break info.
*/
- void GetLineBreakPositions( const Character* const text,
- Length numberOfCharacters,
- LineBreakInfo* breakInfo );
+ void GetLineBreakPositions(const Character* const text,
+ Length numberOfCharacters,
+ LineBreakInfo* breakInfo);
/**
* @brief Retrieves the word break info.
* @param[in] numberOfCharacters The number of characters.
* @param[out] breakInfo The word break info.
*/
- void GetWordBreakPositions( const Character* const text,
- Length numberOfCharacters,
- WordBreakInfo* breakInfo );
+ void GetWordBreakPositions(const Character* const text,
+ Length numberOfCharacters,
+ WordBreakInfo* breakInfo);
};
} // namespace TextAbstraction
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace TextAbstraction
{
-
Shaping::Shaping()
{
}
{
}
-Shaping::Shaping( Internal::Shaping *impl )
-: BaseHandle( impl )
+Shaping::Shaping(Internal::Shaping* impl)
+: BaseHandle(impl)
{
}
return Internal::Shaping::Get();
}
-Length Shaping::Shape( const Character* const text,
- Length numberOfCharacters,
- FontId fontId,
- Script script )
+Length Shaping::Shape(const Character* const text,
+ Length numberOfCharacters,
+ FontId fontId,
+ Script script)
{
- return GetImplementation( *this ).Shape( text,
- numberOfCharacters,
- fontId,
- script );
+ return GetImplementation(*this).Shape(text,
+ numberOfCharacters,
+ fontId,
+ script);
}
-void Shaping::GetGlyphs( GlyphInfo* glyphInfo,
- CharacterIndex* glyphToCharacterMap )
+void Shaping::GetGlyphs(GlyphInfo* glyphInfo,
+ CharacterIndex* glyphToCharacterMap)
{
- GetImplementation( *this ).GetGlyphs( glyphInfo,
- glyphToCharacterMap );
+ GetImplementation(*this).GetGlyphs(glyphInfo,
+ glyphToCharacterMap);
}
} // namespace TextAbstraction
#define DALI_PLATFORM_TEXT_ABSTRACTION_SHAPING_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace TextAbstraction
{
-
struct GlyphInfo;
namespace Internal DALI_INTERNAL
{
-
class Shaping;
-} // Internal
+} // namespace DALI_INTERNAL
/**
* @brief Shaping provides an interface to retrieve glyphs from complex text.
*/
class DALI_ADAPTOR_API Shaping : public BaseHandle
{
-
public:
-
/**
* @brief Create an uninitialized Shaping handle.
*
*
* @param[in] implementation A pointer to the internal shaping object.
*/
- explicit DALI_INTERNAL Shaping( Internal::Shaping* implementation );
+ explicit DALI_INTERNAL Shaping(Internal::Shaping* implementation);
/**
* @brief Retrieve a handle to the Shaping instance.
*
* @return The size of the buffer required to get the shaped text.
*/
- Length Shape( const Character* const text,
- Length numberOfCharacters,
- FontId fontId,
- Script script );
+ Length Shape(const Character* const text,
+ Length numberOfCharacters,
+ FontId fontId,
+ Script script);
/**
* Gets the shaped text data.
* @param[out] glyphInfo Vector with indices to the glyph within the font, glyph's metrics and advance.
* @param[out] glyphToCharacterMap The glyph to character conversion map.
*/
- void GetGlyphs( GlyphInfo* glyphInfo,
- CharacterIndex* glyphToCharacterMap );
+ void GetGlyphs(GlyphInfo* glyphInfo,
+ CharacterIndex* glyphToCharacterMap);
};
} // namespace TextAbstraction
#define DALI_TEXT_ABSTRACTION_DEFINITIONS_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace TextAbstraction
{
-
typedef uint32_t FontId; ///< The unique identifier for a font face (generated by FontClient)
typedef uint32_t PointSize26Dot6; ///< The point size in 26.6 fractional points
typedef uint32_t FaceIndex; ///< Used with fonts which allow several font faces
*/
enum class ColorBlendingMode
{
- NONE, ///< No blend.
- MULTIPLY ///< The color is multiplied by another one.
+ NONE, ///< No blend.
+ MULTIPLY ///< The color is multiplied by another one.
};
} // namespace TextAbstraction
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace TextAbstraction
{
-
-void TransformToArc( const CircularTextParameters& parameters, double& x, double& y )
+void TransformToArc(const CircularTextParameters& parameters, double& x, double& y)
{
double yP = y;
// Does the italic synthesization for circular layout.
- if( parameters.synthesizeItalic )
+ if(parameters.synthesizeItalic)
{
- const double xP = -yP * sin( TextAbstraction::FontClient::DEFAULT_ITALIC_ANGLE );
- yP *= cos( TextAbstraction::FontClient::DEFAULT_ITALIC_ANGLE );
+ const double xP = -yP * sin(TextAbstraction::FontClient::DEFAULT_ITALIC_ANGLE);
+ yP *= cos(TextAbstraction::FontClient::DEFAULT_ITALIC_ANGLE);
x += xP;
}
- double angle = 0.0;
+ double angle = 0.0;
double radius = parameters.radius;
// Transform to a circular layout.
- if( parameters.isClockwise )
+ if(parameters.isClockwise)
{
angle = parameters.beginAngle - parameters.invRadius * x;
radius -= yP;
- x = radius * cos( angle );
- y = -radius * sin( angle );
+ x = radius * cos(angle);
+ y = -radius * sin(angle);
}
else
{
angle = parameters.beginAngle + parameters.invRadius * x;
radius += yP;
- x = radius * cos( angle );
- y = radius * sin( -angle );
+ x = radius * cos(angle);
+ y = radius * sin(-angle);
}
// Transforms to the text area coordinate system.
#define DALI_PLATFORM_TEXT_ABSTRACTION_TEXT_RENDERER_LAYOUT_HELPER_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace TextAbstraction
{
-
/**
* @brief Parameters used to transform the vertices of the glyphs to wrap a circular path.
*/
struct DALI_ADAPTOR_API CircularTextParameters
{
CircularTextParameters()
- : centerX{ 0.0 },
- centerY{ 0.0 },
- radius{ 0.0 },
- invRadius{ 0.0 },
- beginAngle{ 0.0 },
- isClockwise{ true },
- synthesizeItalic{ false }
- {}
+ : centerX{0.0},
+ centerY{0.0},
+ radius{0.0},
+ invRadius{0.0},
+ beginAngle{0.0},
+ isClockwise{true},
+ synthesizeItalic{false}
+ {
+ }
- double centerX; ///< The 'x' center of the circular path.
- double centerY; ///< The 'y' center of the circular path.
- double radius; ///< The radius in pixels.
- double invRadius; ///< 1.0 / radius.
- double beginAngle; ///< The angle in radians where the circular text begins.
- bool isClockwise:1; ///< Whether the circular text layout is clockwise.
- bool synthesizeItalic:1; ///< Whether to synthesize italic.
+ double centerX; ///< The 'x' center of the circular path.
+ double centerY; ///< The 'y' center of the circular path.
+ double radius; ///< The radius in pixels.
+ double invRadius; ///< 1.0 / radius.
+ double beginAngle; ///< The angle in radians where the circular text begins.
+ bool isClockwise : 1; ///< Whether the circular text layout is clockwise.
+ bool synthesizeItalic : 1; ///< Whether to synthesize italic.
};
/**
* @param[in,out] x The 'x' coordinate of the vertex.
* @param[in,out] y The 'y' coordinate of the vertex.
*/
-DALI_ADAPTOR_API void TransformToArc( const CircularTextParameters& parameters, double& x, double& y );
+DALI_ADAPTOR_API void TransformToArc(const CircularTextParameters& parameters, double& x, double& y);
} // namespace TextAbstraction
/*
-* Copyright (c) 2019 Samsung Electronics Co., Ltd.
+* Copyright (c) 2020 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.
namespace Dali
{
-
namespace TextAbstraction
{
-
TextRenderer::TextRenderer()
{
}
return GetImplementation(*this).Render(parameters);
}
-TextRenderer::TextRenderer(Internal::TextRenderer *impl)
+TextRenderer::TextRenderer(Internal::TextRenderer* impl)
: BaseHandle(impl)
{
}
#define DALI_TOOLKIT_TEXT_ABSTRACTION_TEXT_RENDERER_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
#include <dali/public-api/object/base-handle.h>
// INTERNAL INCLUDES
-#include <dali/devel-api/text-abstraction/glyph-info.h>
#include <dali/devel-api/adaptor-framework/pixel-buffer.h>
+#include <dali/devel-api/text-abstraction/glyph-info.h>
namespace Dali
{
-
namespace TextAbstraction
{
-
namespace Internal
{
-
- // Forward declaration
- class TextRenderer;
+// Forward declaration
+class TextRenderer;
} // namespace Internal
/**
* @brief Parameters for the text renderer function.
*/
- Parameters( Vector<GlyphInfo>& glyphs,
- Vector<Vector2>& positions,
- Vector<Vector4>& colors,
- Vector<ColorIndex>& colorIndices,
- Vector<ColorBlendingMode>& blendingMode,
- Vector<bool>& isEmoji )
- : glyphs( glyphs ),
- positions( positions ),
- colors( colors ),
- colorIndices( colorIndices ),
- blendingMode( blendingMode ),
- isEmoji( isEmoji ),
- width{ 0u },
- height{ 0u },
- radius{ 0u },
- circularWidth{ 0u },
- circularHeight{ 0u },
- centerX{ 0 },
- centerY{ 0 },
- beginAngle{ 0.f },
- pixelFormat{ A8 },
- circularLayout{ CLOCKWISE }
- {}
-
- Vector<GlyphInfo>& glyphs; ///< The glyphs to be rendered.
- Vector<Vector2>& positions; ///< The position for each glyph.
- Vector<Vector4>& colors; ///< Colors of the glyphs.
- Vector<ColorIndex>& colorIndices; ///< Indices to the vector of colors for each glyphs.
- Vector<ColorBlendingMode>& blendingMode; ///< How each glyph is going to be blended with the color of the text.
- Vector<bool>& isEmoji; ///< Whether each glyph is an emoji.
- unsigned int width; ///< The width of the pixel buffer. @note Some implementations may change the width for performance reasons.
- unsigned int height; ///< The height of the pixel buffer.
- unsigned int radius; ///< The radius in pixels of the circular text.
- unsigned int circularWidth; ///< The width of the text laid out on an horizontal straight line.
- unsigned int circularHeight; ///< The height of the text laid out on an horizontal straight line.
- int centerX; ///< The 'x' coordinate of the center. For circular layout.
- int centerY; ///< The 'y' coordinate of the center. For circular layout.
- float beginAngle; ///< The angle in radians where the circular text begins.
- PixelFormat pixelFormat; ///< The pixel format of the pixel buffer.
- CircularLayout circularLayout; ///< The direction of the text's layout.
+ Parameters(Vector<GlyphInfo>& glyphs,
+ Vector<Vector2>& positions,
+ Vector<Vector4>& colors,
+ Vector<ColorIndex>& colorIndices,
+ Vector<ColorBlendingMode>& blendingMode,
+ Vector<bool>& isEmoji)
+ : glyphs(glyphs),
+ positions(positions),
+ colors(colors),
+ colorIndices(colorIndices),
+ blendingMode(blendingMode),
+ isEmoji(isEmoji),
+ width{0u},
+ height{0u},
+ radius{0u},
+ circularWidth{0u},
+ circularHeight{0u},
+ centerX{0},
+ centerY{0},
+ beginAngle{0.f},
+ pixelFormat{A8},
+ circularLayout{CLOCKWISE}
+ {
+ }
+
+ Vector<GlyphInfo>& glyphs; ///< The glyphs to be rendered.
+ Vector<Vector2>& positions; ///< The position for each glyph.
+ Vector<Vector4>& colors; ///< Colors of the glyphs.
+ Vector<ColorIndex>& colorIndices; ///< Indices to the vector of colors for each glyphs.
+ Vector<ColorBlendingMode>& blendingMode; ///< How each glyph is going to be blended with the color of the text.
+ Vector<bool>& isEmoji; ///< Whether each glyph is an emoji.
+ unsigned int width; ///< The width of the pixel buffer. @note Some implementations may change the width for performance reasons.
+ unsigned int height; ///< The height of the pixel buffer.
+ unsigned int radius; ///< The radius in pixels of the circular text.
+ unsigned int circularWidth; ///< The width of the text laid out on an horizontal straight line.
+ unsigned int circularHeight; ///< The height of the text laid out on an horizontal straight line.
+ int centerX; ///< The 'x' coordinate of the center. For circular layout.
+ int centerY; ///< The 'y' coordinate of the center. For circular layout.
+ float beginAngle; ///< The angle in radians where the circular text begins.
+ PixelFormat pixelFormat; ///< The pixel format of the pixel buffer.
+ CircularLayout circularLayout; ///< The direction of the text's layout.
};
public:
-
/**
* @brief Create an uninitialized TextRenderer handle.
*
Devel::PixelBuffer Render(const Parameters& parameters);
public: // Not intended for application developers.
-
/// @cond internal
/**
* @brief This constructor is used by TextRenderer::Get().
*/
// EXTERNAL INCLUDES
-#include <dali/public-api/signals/callback.h>
-#include <dali/public-api/signals/dali-signal.h>
-#include <dali/public-api/math/uint-16-pair.h>
-#include <dali/public-api/math/rect.h>
-#include <dali/public-api/object/any.h>
#include <dali/devel-api/events/touch-point.h>
#include <dali/integration-api/processor-interface.h>
+#include <dali/public-api/math/rect.h>
+#include <dali/public-api/math/uint-16-pair.h>
+#include <dali/public-api/object/any.h>
+#include <dali/public-api/signals/callback.h>
+#include <dali/public-api/signals/dali-signal.h>
// INTERNAL INCLUDES
+#include <dali/integration-api/adaptor-framework/log-factory-interface.h>
#include <dali/public-api/adaptor-framework/window.h>
#include <dali/public-api/dali-adaptor-common.h>
-#include <dali/integration-api/adaptor-framework/log-factory-interface.h>
namespace Dali
{
-
class ObjectRegistry;
class RenderSurfaceInterface;
using SceneHolderList = std::vector<Dali::Integration::SceneHolder>;
-
namespace Internal
{
namespace Adaptor
{
class GraphicsFactory;
class Adaptor;
-}
-}
+} // namespace Adaptor
+} // namespace Internal
/**
* @brief An Adaptor object is used to initialize and control how Dali runs.
class DALI_ADAPTOR_API Adaptor
{
public:
-
- typedef Signal< void (Adaptor&) > AdaptorSignalType; ///< Generic Type for adaptor signals
- typedef Signal< void (Dali::Integration::SceneHolder&) > WindowCreatedSignalType; ///< SceneHolder created signal type
+ typedef Signal<void(Adaptor&)> AdaptorSignalType; ///< Generic Type for adaptor signals
+ typedef Signal<void(Dali::Integration::SceneHolder&)> WindowCreatedSignalType; ///< SceneHolder created signal type
using SurfaceSize = Uint16Pair; ///< Surface size type
* @param[in] window The window to draw onto
* @return a reference to the adaptor handle
*/
- static Adaptor& New( Window window );
+ static Adaptor& New(Window window);
/**
* @brief Create a new adaptor using render surface.
* @param[in] surface The surface to draw onto
* @return a reference to the adaptor handle
*/
- static Adaptor& New( Window window, const Dali::RenderSurfaceInterface& surface );
+ static Adaptor& New(Window window, const Dali::RenderSurfaceInterface& surface);
/**
* @brief Create a new adaptor using the SceneHolder.
* @param[in] sceneHolder The SceneHolder to draw onto
* @return a reference to the adaptor handle
*/
- static Adaptor& New( Dali::Integration::SceneHolder sceneHolder );
+ static Adaptor& New(Dali::Integration::SceneHolder sceneHolder);
/**
* @brief Create a new adaptor using render surface.
* @param[in] surface The surface to draw onto
* @return a reference to the adaptor handle
*/
- static Adaptor& New( Dali::Integration::SceneHolder sceneHolder, const Dali::RenderSurfaceInterface& surface );
+ static Adaptor& New(Dali::Integration::SceneHolder sceneHolder, const Dali::RenderSurfaceInterface& surface);
/**
* @brief Virtual Destructor.
virtual ~Adaptor();
public:
-
/**
* @brief Starts the Adaptor.
*/
*
* @note Ownership of the callback is passed onto this class.
*/
- bool AddIdle( CallbackBase* callback, bool hasReturnValue );
+ bool AddIdle(CallbackBase* callback, bool hasReturnValue);
/**
* @brief Adds a new Window instance to the Adaptor
*
* @param[in] childWindow The child window instance
*/
- bool AddWindow( Dali::Integration::SceneHolder childWindow );
+ bool AddWindow(Dali::Integration::SceneHolder childWindow);
/**
* @brief Removes a previously added @p callback.
*
* @param[in] callback The callback to be removed.
*/
- void RemoveIdle( CallbackBase* callback );
+ void RemoveIdle(CallbackBase* callback);
/**
* @brief Processes the idle callbacks.
* @param[in] window The window to replace the surface for
* @param[in] surface to use
*/
- void ReplaceSurface( Window window, Dali::RenderSurfaceInterface& surface );
+ void ReplaceSurface(Window window, Dali::RenderSurfaceInterface& surface);
/**
* @brief Replaces the rendering surface
* @param[in] sceneHolder The SceneHolder to replace the surface for
* @param[in] surface to use
*/
- void ReplaceSurface( Dali::Integration::SceneHolder sceneHolder, Dali::RenderSurfaceInterface& surface );
+ void ReplaceSurface(Dali::Integration::SceneHolder sceneHolder, Dali::RenderSurfaceInterface& surface);
/**
* @brief Get the render surface the adaptor is using to render to.
* @param[in] actor The actor
* @return native window handle
*/
- Any GetNativeWindowHandle( Actor actor );
+ Any GetNativeWindowHandle(Actor actor);
/**
* @brief Get the native display associated with the graphics backend
* 4 - render every fourth vsync frame
* 8 - render every eighth vsync frame
*/
- void SetRenderRefreshRate( unsigned int numberOfVSyncsPerRender );
+ void SetRenderRefreshRate(unsigned int numberOfVSyncsPerRender);
/**
* @brief The callback is called from the Update/Render thread prior to rendering.
* @endcode
* This callback will be called repeatedly as long as it returns true. A return of 0 deletes this callback.
*/
- void SetPreRenderCallback( CallbackBase* callback );
+ void SetPreRenderCallback(CallbackBase* callback);
/**
* @brief Returns a reference to the instance of the adaptor used by the current thread.
* @param[in] point touch point
* @param[in] timeStamp time value of event
*/
- void FeedTouchPoint( TouchPoint& point, int timeStamp );
+ void FeedTouchPoint(TouchPoint& point, int timeStamp);
/**
* @brief Feed a wheel event to the adaptor.
*
* @param[in] wheelEvent wheel event
*/
- void FeedWheelEvent( WheelEvent& wheelEvent );
+ void FeedWheelEvent(WheelEvent& wheelEvent);
/**
* @brief Feed a key event to the adaptor.
*
* @param[in] keyEvent The key event holding the key information.
*/
- void FeedKeyEvent( KeyEvent& keyEvent );
+ void FeedKeyEvent(KeyEvent& keyEvent);
/**
* @copydoc Dali::Core::SceneCreated();
* @param[in] surface The current render surface
* @param[in] surfaceSize The new surface size
*/
- void SurfaceResizePrepare( Dali::RenderSurfaceInterface* surface, SurfaceSize surfaceSize );
+ void SurfaceResizePrepare(Dali::RenderSurfaceInterface* surface, SurfaceSize surfaceSize);
/**
* @brief Informs ThreadController the surface size has changed.
* @param[in] surface The current render surface
* @param[in] surfaceSize The new surface size
*/
- void SurfaceResizeComplete( Dali::RenderSurfaceInterface* surface, SurfaceSize surfaceSize );
+ void SurfaceResizeComplete(Dali::RenderSurfaceInterface* surface, SurfaceSize surfaceSize);
/**
* @brief Renders once more even if we're paused
* @param[in] processor the Processor to register
* @note using this api does not maintain the processor's lifecycle, must be done elsewhere.
*/
- void RegisterProcessor( Integration::Processor& processor );
+ void RegisterProcessor(Integration::Processor& processor);
/**
* @brief Unregister a previously registered processor from dali-core.
* @param[in] processor the Processor to unregister
*/
- void UnregisterProcessor( Integration::Processor& processor );
+ void UnregisterProcessor(Integration::Processor& processor);
/**
* @brief Get the list of windows created.
*/
void OnWindowHidden();
-public: // Signals
-
+public: // Signals
/**
* @brief The user should connect to this signal if they need to perform any
* special activities when the surface Dali is being rendered on is resized.
WindowCreatedSignalType& WindowCreatedSignal();
private:
-
// Undefined
Adaptor(const Adaptor&);
Adaptor& operator=(Adaptor&);
private:
-
/**
* @brief Create an uninitialized Adaptor.
*/
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Integration
{
-
AndroidFramework& AndroidFramework::New()
{
return Internal::Adaptor::AndroidFramework::New();
Internal::Adaptor::AndroidFramework::Delete();
}
-void AndroidFramework::SetNativeApplication( android_app* application )
+void AndroidFramework::SetNativeApplication(android_app* application)
{
- mImpl->SetNativeApplication( application );
+ mImpl->SetNativeApplication(application);
}
android_app* AndroidFramework::GetNativeApplication() const
return mImpl->GetNativeApplication();
}
-void AndroidFramework::SetJVM( JavaVM* jvm )
+void AndroidFramework::SetJVM(JavaVM* jvm)
{
- mImpl->SetJVM( jvm );
+ mImpl->SetJVM(jvm);
}
JavaVM* AndroidFramework::GetJVM() const
return mImpl->GetJVM();
}
-void AndroidFramework::SetApplicationAssets( AAssetManager* assets )
+void AndroidFramework::SetApplicationAssets(AAssetManager* assets)
{
- mImpl->SetApplicationAssets( assets );
+ mImpl->SetApplicationAssets(assets);
}
AAssetManager* AndroidFramework::GetApplicationAssets() const
return mImpl->GetApplicationAssets();
}
-void AndroidFramework::SetInternalDataPath( const std::string& path )
+void AndroidFramework::SetInternalDataPath(const std::string& path)
{
- mImpl->SetInternalDataPath( path );
+ mImpl->SetInternalDataPath(path);
}
std::string AndroidFramework::GetInternalDataPath() const
return mImpl->GetInternalDataPath();
}
-void AndroidFramework::SetApplicationConfiguration( AConfiguration* configuration )
+void AndroidFramework::SetApplicationConfiguration(AConfiguration* configuration)
{
- mImpl->SetApplicationConfiguration( configuration );
+ mImpl->SetApplicationConfiguration(configuration);
}
AConfiguration* AndroidFramework::GetApplicationConfiguration() const
return mImpl->GetApplicationConfiguration();
}
-void AndroidFramework::SetApplicationWindow( ANativeWindow* window )
+void AndroidFramework::SetApplicationWindow(ANativeWindow* window)
{
- mImpl->SetApplicationWindow( window );
+ mImpl->SetApplicationWindow(window);
}
ANativeWindow* AndroidFramework::GetApplicationWindow() const
mImpl->OnResume();
}
-void AndroidFramework::OnWindowCreated( ANativeWindow* window )
+void AndroidFramework::OnWindowCreated(ANativeWindow* window)
{
- mImpl->OnWindowCreated( window );
+ mImpl->OnWindowCreated(window);
}
-void AndroidFramework::OnWindowDestroyed( ANativeWindow* window )
+void AndroidFramework::OnWindowDestroyed(ANativeWindow* window)
{
- mImpl->OnWindowDestroyed( window );
+ mImpl->OnWindowDestroyed(window);
}
AndroidFramework::~AndroidFramework()
}
AndroidFramework::AndroidFramework()
-: mImpl( nullptr )
+: mImpl(nullptr)
{
}
// EXTERNAL INCLUDES
#include <string>
-#include <jni.h>
#include <android/asset_manager.h>
#include <android/asset_manager_jni.h>
#include <android/configuration.h>
#include <android/native_window.h>
#include <android/native_window_jni.h>
+#include <jni.h>
#ifndef _ANDROID_NATIVE_APP_GLUE_H
extern "C"
{
-struct android_app;
+ struct android_app;
}
#endif
namespace Dali
{
-
namespace Internal DALI_INTERNAL
{
-
namespace Adaptor
{
class AndroidFramework;
}
-}
+} // namespace DALI_INTERNAL
namespace Integration
{
-
/**
* AndroidFramework provides setter/getter for Android native interfaces for Android DALi Adaptor.
* It is also used to pass Android application events to Android DALi Adaptor.
* @brief Sets the Android native application glue struct
* @param[in] application A pointer to the application glue struct
*/
- void SetNativeApplication( android_app* application );
+ void SetNativeApplication(android_app* application);
/**
* @brief Gets the Android native application glue struct
* @brief Sets the Android JVM
* @param[in] jvm A pointer to Android JVM
*/
- void SetJVM( JavaVM* jvm );
+ void SetJVM(JavaVM* jvm);
/**
* @brief Sets the JVM
* Sets the Android application assets manager.
* @param[in] assets A pointer to assets manager
*/
- void SetApplicationAssets( AAssetManager* assets );
+ void SetApplicationAssets(AAssetManager* assets);
/**
* @brief Gets the Android application assets manager.
* Sets the Android application internal data path.
* @param[in] path A path to the application data path
*/
- void SetInternalDataPath( const std::string& path );
+ void SetInternalDataPath(const std::string& path);
/**
* Gets the Android application internal data path.
* @brief Sets the Android application configuration
* @param[in] configuration A pointer to Android application configuration
*/
- void SetApplicationConfiguration( AConfiguration* configuration );
+ void SetApplicationConfiguration(AConfiguration* configuration);
/**
* @brief Gets the Android application configuration
* @brief Sets the Android application native window
* @return A native window
*/
- void SetApplicationWindow( ANativeWindow* window );
+ void SetApplicationWindow(ANativeWindow* window);
/**
* @brief Gets the Android application native window
/**
* Invoked when the Android application native window is created.
*/
- void OnWindowCreated( ANativeWindow* window );
+ void OnWindowCreated(ANativeWindow* window);
/**
* Invoked when the Android application native window is deleted.
*/
- void OnWindowDestroyed( ANativeWindow* window );
+ void OnWindowDestroyed(ANativeWindow* window);
/**
* @brief Returns a reference to the instance of the Android framework used by the current thread.
virtual ~AndroidFramework();
// Not copyable or movable
- AndroidFramework( const AndroidFramework& ) = delete; ///< Deleted copy constructor
- AndroidFramework( AndroidFramework&& ) = delete; ///< Deleted move constructor
- AndroidFramework& operator=( const AndroidFramework& ) = delete; ///< Deleted copy assignment operator
- AndroidFramework& operator=( AndroidFramework&& ) = delete; ///< Deleted move assignment operator
+ AndroidFramework(const AndroidFramework&) = delete; ///< Deleted copy constructor
+ AndroidFramework(AndroidFramework&&) = delete; ///< Deleted move constructor
+ AndroidFramework& operator=(const AndroidFramework&) = delete; ///< Deleted copy assignment operator
+ AndroidFramework& operator=(AndroidFramework&&) = delete; ///< Deleted move assignment operator
private:
-
/**
* @brief Create an uninitialized AndroidFramework.
*/
} // namespace Dali
#endif // DALI_INTEGRATION_ANDROID_FRAMEWORK_H
-
#define DALI_INTEGRATION_APPLICATION_LAUNCHER_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*
*/
-#include <jni.h>
#include <dali/devel-api/adaptor-framework/application-devel.h>
+#include <jni.h>
using namespace Dali;
struct ApplicationLauncher
{
static RefObject* applicationObject;
- ApplicationLauncher( Application& application )
+ ApplicationLauncher(Application& application)
{
applicationObject = application.GetObjectPtr();
}
namespace
{
-
// JNI native "nativeOnCreate" callback when DaliView is created
-jlong OnCreate(JNIEnv *jenv, jobject obj)
+jlong OnCreate(JNIEnv* jenv, jobject obj)
{
// Extra reference to prevent finalize clearing the app
ApplicationLauncher::applicationObject->Reference();
// not blocking, does nothing except for the setting of the running flag
- DevelApplication::DownCast( ApplicationLauncher::applicationObject ).MainLoop();
+ DevelApplication::DownCast(ApplicationLauncher::applicationObject).MainLoop();
- return reinterpret_cast<jlong>( ApplicationLauncher::applicationObject );
+ return reinterpret_cast<jlong>(ApplicationLauncher::applicationObject);
};
-}
+} // namespace
// JNI daliview library on load entry function. Registers nativeOnCreate callback for DaliView Java class.
-JNIEXPORT jint JNI_OnLoad(JavaVM *vm, void *reserved)
+JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved)
{
JNIEnv* env = nullptr;
- if( vm->GetEnv( reinterpret_cast<void **>( &env ), JNI_VERSION_1_6) != JNI_OK )
+ if(vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK)
{
return JNI_ERR;
}
// Find DaliView Java class. JNI_OnLoad is called from the correct class loader context for this to work.
- jclass clazz = env->FindClass( "com/sec/daliview/DaliView" );
- if( clazz == nullptr )
+ jclass clazz = env->FindClass("com/sec/daliview/DaliView");
+ if(clazz == nullptr)
{
return JNI_ERR;
}
// Register your class' native methods.
static const JNINativeMethod methods[] =
- {
- { "nativeOnCreate", "()J", (void *)&OnCreate },
- };
+ {
+ {"nativeOnCreate", "()J", (void*)&OnCreate},
+ };
int rc = env->RegisterNatives(clazz, methods, sizeof(methods) / sizeof(JNINativeMethod));
- if (rc != JNI_OK)
+ if(rc != JNI_OK)
return rc;
return JNI_VERSION_1_6;
// This macro facilitates creation of DALi application and launch when DaliView is created.
// The DALi application controller is passed to the application created by DaliView JNI library.
-#define RUN(Controller) Application application = Application::New(); \
- Controller controller( application ); \
- ApplicationLauncher launcher( application ); \
+#define RUN(Controller) \
+ Application application = Application::New(); \
+ Controller controller(application); \
+ ApplicationLauncher launcher(application);
#endif // DALI_INTEGRATION_APPLICATION_LAUNCHER_H
-
#define DALI_INTEGRATION_EGL_INTERFACE_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
enum ColorDepth
{
COLOR_DEPTH_24 = 24,
/**
* Make the OpenGL context current
*/
- virtual void MakeContextCurrent( EGLSurface eglSurface, EGLContext eglContext ) = 0;
+ virtual void MakeContextCurrent(EGLSurface eglSurface, EGLContext eglContext) = 0;
/**
* Terminate GL
/**
* Performs an OpenGL swap buffers command
*/
- virtual void SwapBuffers( EGLSurface& eglSurface ) = 0;
+ virtual void SwapBuffers(EGLSurface& eglSurface) = 0;
/**
* Performs an OpenGL copy buffers command
*/
- virtual void CopyBuffers( EGLSurface& eglSurface ) = 0;
+ virtual void CopyBuffers(EGLSurface& eglSurface) = 0;
/**
* Performs an EGL wait GL command
/**
* Virtual protected destructor, no deletion through this interface
*/
- virtual ~EglInterface() {}
+ virtual ~EglInterface()
+ {
+ }
};
} // namespace Dali
#define DALI_ADAPTOR_LOG_FACTORY_INTERFACE_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
class LogFactoryInterface
{
public:
} // namespace Dali
-
#endif //DALI_ADAPTOR_LOG_FACTORY_INTERFACE_H
namespace Dali
{
-
class NativeRenderSurface;
/**
* If you don't pass this, a native surface will be created.
* @param [in] isTransparent Whether the surface has an alpha channel
*/
-NativeRenderSurface* CreateNativeSurface( SurfaceSize surfaceSize, Any surface,
- bool isTransparent );
+NativeRenderSurface* CreateNativeSurface(SurfaceSize surfaceSize, Any surface, bool isTransparent);
} // namespace Dali
#define DALI_NATIVE_RENDER_SURFACE_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
// INTERNAL INCLUDES
-#include <dali/public-api/dali-adaptor-common.h>
#include <dali/integration-api/adaptor-framework/render-surface-interface.h>
+#include <dali/public-api/dali-adaptor-common.h>
namespace Dali
{
-
class TriggerEventInterface;
/**
class DALI_ADAPTOR_API NativeRenderSurface : public Dali::RenderSurfaceInterface
{
public:
-
/**
* @brief Default constructor
*/
virtual ~NativeRenderSurface() = default;
public: // API
-
/**
* @brief Get the render surface the adaptor is using to render to.
* @return reference to current render surface
* @brief Sets the render notification trigger to call when render thread is completed a frame
* @param renderNotification to use
*/
- virtual void SetRenderNotification( TriggerEventInterface* renderNotification ) = 0;
+ virtual void SetRenderNotification(TriggerEventInterface* renderNotification) = 0;
/**
* @brief Waits until surface is replaced
virtual void WaitUntilSurfaceReplaced() = 0;
private: // from NativeRenderSurface
-
/**
* @brief Create a renderable
*/
virtual void ReleaseDrawable() = 0;
protected:
-
// Undefined
NativeRenderSurface(const NativeRenderSurface&) = delete;
// Undefined
NativeRenderSurface& operator=(const NativeRenderSurface& rhs) = delete;
-
};
} // namespace Dali
// EXTERNAL INCLUDES
#include <dali/integration-api/core-enumerations.h>
+#include <dali/integration-api/scene.h>
#include <dali/public-api/common/vector-wrapper.h>
-#include <dali/public-api/math/vector4.h>
#include <dali/public-api/math/rect.h>
+#include <dali/public-api/math/uint-16-pair.h>
+#include <dali/public-api/math/vector4.h>
#include <dali/public-api/object/any.h>
#include <dali/public-api/object/weak-handle.h>
-#include <dali/integration-api/scene.h>
-#include <dali/public-api/math/uint-16-pair.h>
namespace Dali
{
-
class DisplayConnection;
class ThreadSynchronizationInterface;
{
class AdaptorInternalServices;
class GraphicsInterface;
-}
-}
+} // namespace Adaptor
+} // namespace Internal
/**
* @brief The position and size of the render surface.
*/
-using PositionSize = Dali::Rect<int>;
-using SurfaceSize = Uint16Pair;
+using PositionSize = Dali::Rect<int>;
+using SurfaceSize = Uint16Pair;
/**
* @brief Interface for a render surface onto which Dali draws.
class RenderSurfaceInterface
{
public:
-
enum Type
{
WINDOW_RENDER_SURFACE,
* Inlined as this is a pure abstract interface
*/
RenderSurfaceInterface()
- : mAdaptor( nullptr ),
- mGraphics( nullptr ),
- mDisplayConnection( nullptr ),
+ : mAdaptor(nullptr),
+ mGraphics(nullptr),
+ mDisplayConnection(nullptr),
mScene(),
- mFullSwapNextFrame( true ),
- mDepthBufferRequired( Integration::DepthBufferAvailable::FALSE ),
- mStencilBufferRequired( Integration::StencilBufferAvailable::FALSE )
- {}
+ mFullSwapNextFrame(true),
+ mDepthBufferRequired(Integration::DepthBufferAvailable::FALSE),
+ mStencilBufferRequired(Integration::StencilBufferAvailable::FALSE)
+ {
+ }
/**
* @brief Virtual Destructor.
* Inlined as this is a pure abstract interface
*/
- virtual ~RenderSurfaceInterface() {}
+ virtual ~RenderSurfaceInterface()
+ {
+ }
/**
* @brief Return the size and position of the surface.
* @param[out] dpiHorizontal set to the horizontal dpi
* @param[out] dpiVertical set to the vertical dpi
*/
- virtual void GetDpi( unsigned int& dpiHorizontal, unsigned int& dpiVertical ) = 0;
+ virtual void GetDpi(unsigned int& dpiHorizontal, unsigned int& dpiVertical) = 0;
/**
* @brief InitializeGraphics the platform specific graphics surface interfaces
* @brief Resizes the underlying surface.
* @param[in] The dimensions of the new position
*/
- virtual void MoveResize( Dali::PositionSize positionSize ) = 0;
+ virtual void MoveResize(Dali::PositionSize positionSize) = 0;
/**
* @brief Called when Render thread has started
* @param[in] damagedRects List of damaged rects this render pass
* @return True if the operation is successful, False if the operation failed
*/
- virtual bool PreRender( bool resizingSurface, const std::vector<Rect<int>>& damagedRects, Rect<int>& clippingRect ) = 0;
+ virtual bool PreRender(bool resizingSurface, const std::vector<Rect<int>>& damagedRects, Rect<int>& clippingRect) = 0;
/**
* @brief Invoked by render thread after Core::Render
* @param[in] replacingSurface True if the surface is being replaced.
* @param[in] resizingSurface True if the surface is being resized.
*/
- virtual void PostRender( bool renderToFbo, bool replacingSurface, bool resizingSurface, const std::vector<Rect<int>>& damagedRects ) = 0;
+ virtual void PostRender(bool renderToFbo, bool replacingSurface, bool resizingSurface, const std::vector<Rect<int>>& damagedRects) = 0;
/**
* @brief Invoked by render thread when the thread should be stop
*
* @param threadSynchronization The thread-synchronization implementation.
*/
- virtual void SetThreadSynchronization( ThreadSynchronizationInterface& threadSynchronization ) = 0;
+ virtual void SetThreadSynchronization(ThreadSynchronizationInterface& threadSynchronization) = 0;
/**
* @brief Gets the surface type
virtual Integration::StencilBufferAvailable GetStencilBufferRequired() = 0;
public:
-
- void SetAdaptor( Dali::Internal::Adaptor::AdaptorInternalServices& adaptor )
+ void SetAdaptor(Dali::Internal::Adaptor::AdaptorInternalServices& adaptor)
{
mAdaptor = &adaptor;
}
- void SetGraphicsInterface( Dali::Internal::Adaptor::GraphicsInterface& graphics )
+ void SetGraphicsInterface(Dali::Internal::Adaptor::GraphicsInterface& graphics)
{
mGraphics = &graphics;
}
- void SetDisplayConnection( Dali::DisplayConnection& displayConnection )
+ void SetDisplayConnection(Dali::DisplayConnection& displayConnection)
{
mDisplayConnection = &displayConnection;
}
* @brief Sets a Scene that is rendered on this surface.
* @param scene The Scene object
*/
- void SetScene( Dali::Integration::Scene& scene )
+ void SetScene(Dali::Integration::Scene& scene)
{
mScene = scene;
}
}
private:
-
/**
* @brief Undefined copy constructor. RenderSurface cannot be copied
*/
- RenderSurfaceInterface( const RenderSurfaceInterface& rhs );
+ RenderSurfaceInterface(const RenderSurfaceInterface& rhs);
/**
* @brief Undefined assignment operator. RenderSurface cannot be copied
*/
- RenderSurfaceInterface& operator=( const RenderSurfaceInterface& rhs );
+ RenderSurfaceInterface& operator=(const RenderSurfaceInterface& rhs);
protected:
-
Dali::Internal::Adaptor::AdaptorInternalServices* mAdaptor;
- Dali::Internal::Adaptor::GraphicsInterface* mGraphics;
- Dali::DisplayConnection* mDisplayConnection;
- WeakHandle< Dali::Integration::Scene > mScene;
- bool mFullSwapNextFrame; ///< Whether the full surface swap is required
+ Dali::Internal::Adaptor::GraphicsInterface* mGraphics;
+ Dali::DisplayConnection* mDisplayConnection;
+ WeakHandle<Dali::Integration::Scene> mScene;
+ bool mFullSwapNextFrame; ///< Whether the full surface swap is required
private:
+ Integration::DepthBufferAvailable mDepthBufferRequired; ///< Whether the depth buffer is required
+ Integration::StencilBufferAvailable mStencilBufferRequired; ///< Whether the stencil buffer is required
- Integration::DepthBufferAvailable mDepthBufferRequired; ///< Whether the depth buffer is required
- Integration::StencilBufferAvailable mStencilBufferRequired; ///< Whether the stencil buffer is required
-
- Vector4 mBackgroundColor; ///< The background color of the surface
+ Vector4 mBackgroundColor; ///< The background color of the surface
};
} // namespace Dali
#include <dali/integration-api/adaptor-framework/scene-holder-impl.h>
// EXTERNAL INCLUDES
-#include <sys/time.h>
-#include <dali/public-api/common/dali-common.h>
-#include <dali/public-api/actors/actor.h>
-#include <dali/public-api/actors/layer.h>
#include <dali/integration-api/debug.h>
+#include <dali/integration-api/events/hover-event-integ.h>
#include <dali/integration-api/events/key-event-integ.h>
#include <dali/integration-api/events/touch-event-integ.h>
-#include <dali/integration-api/events/hover-event-integ.h>
#include <dali/integration-api/events/wheel-event-integ.h>
+#include <dali/public-api/actors/actor.h>
+#include <dali/public-api/actors/layer.h>
+#include <dali/public-api/common/dali-common.h>
+#include <sys/time.h>
// INTERNAL INCLUDES
#include <dali/internal/adaptor/common/adaptor-impl.h>
namespace Dali
{
-
namespace Internal
{
-
namespace Adaptor
{
-
namespace
{
-
#if defined(DEBUG_ENABLED)
-Debug::Filter* gSceneHolderLogFilter = Debug::Filter::New( Debug::NoLogging, false, "LOG_SCENE_HOLDER" );
+Debug::Filter* gSceneHolderLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_SCENE_HOLDER");
#endif
// Copied from x server
{
struct timeval tv;
- struct timespec tp;
+ struct timespec tp;
static clockid_t clockid;
- if (!clockid)
+ if(!clockid)
{
#ifdef CLOCK_MONOTONIC_COARSE
- if (clock_getres(CLOCK_MONOTONIC_COARSE, &tp) == 0 &&
- (tp.tv_nsec / 1000) <= 1000 && clock_gettime(CLOCK_MONOTONIC_COARSE, &tp) == 0)
+ if(clock_getres(CLOCK_MONOTONIC_COARSE, &tp) == 0 &&
+ (tp.tv_nsec / 1000) <= 1000 && clock_gettime(CLOCK_MONOTONIC_COARSE, &tp) == 0)
{
clockid = CLOCK_MONOTONIC_COARSE;
}
else
#endif
- if (clock_gettime(CLOCK_MONOTONIC, &tp) == 0)
+ if(clock_gettime(CLOCK_MONOTONIC, &tp) == 0)
{
clockid = CLOCK_MONOTONIC;
}
clockid = ~0L;
}
}
- if (clockid != ~0L && clock_gettime(clockid, &tp) == 0)
+ if(clockid != ~0L && clock_gettime(clockid, &tp) == 0)
{
- return static_cast<uint32_t>( (tp.tv_sec * 1000 ) + (tp.tv_nsec / 1000000L) );
+ return static_cast<uint32_t>((tp.tv_sec * 1000) + (tp.tv_nsec / 1000000L));
}
gettimeofday(&tv, NULL);
- return static_cast<uint32_t>( (tv.tv_sec * 1000 ) + (tv.tv_usec / 1000) );
+ return static_cast<uint32_t>((tv.tv_sec * 1000) + (tv.tv_usec / 1000));
}
} // unnamed namespace
class SceneHolder::SceneHolderLifeCycleObserver : public LifeCycleObserver
{
public:
-
SceneHolderLifeCycleObserver(Adaptor*& adaptor)
- : mAdaptor( adaptor )
- {
- };
+ : mAdaptor(adaptor){};
private: // Adaptor::LifeCycleObserver interface
-
- void OnStart() override {};
- void OnPause() override {};
- void OnResume() override {};
- void OnStop() override {};
+ void OnStart() override{};
+ void OnPause() override{};
+ void OnResume() override{};
+ void OnStop() override{};
void OnDestroy() override
{
mAdaptor = nullptr;
Adaptor*& mAdaptor;
};
-
SceneHolder::SceneHolder()
-: mLifeCycleObserver( new SceneHolderLifeCycleObserver( mAdaptor ) ),
- mId( mSceneHolderCounter++ ),
- mSurface( nullptr ),
- mAdaptor( nullptr ),
+: mLifeCycleObserver(new SceneHolderLifeCycleObserver(mAdaptor)),
+ mId(mSceneHolderCounter++),
+ mSurface(nullptr),
+ mAdaptor(nullptr),
mDpi(),
- mIsBeingDeleted( false ),
- mAdaptorStarted( false ),
- mVisible( true )
+ mIsBeingDeleted(false),
+ mAdaptorStarted(false),
+ mVisible(true)
{
}
SceneHolder::~SceneHolder()
{
- if ( mAdaptor )
+ if(mAdaptor)
{
- mAdaptor->RemoveObserver( *mLifeCycleObserver.get() );
- mAdaptor->RemoveWindow( this );
+ mAdaptor->RemoveObserver(*mLifeCycleObserver.get());
+ mAdaptor->RemoveWindow(this);
- mAdaptor->DeleteSurface( *mSurface.get() );
+ mAdaptor->DeleteSurface(*mSurface.get());
mAdaptor = nullptr;
}
- if ( mScene )
+ if(mScene)
{
mScene.Discard();
}
}
-void SceneHolder::Add( Dali::Actor actor )
+void SceneHolder::Add(Dali::Actor actor)
{
- if ( mScene )
+ if(mScene)
{
- mScene.Add( actor );
+ mScene.Add(actor);
}
}
-void SceneHolder::Remove( Dali::Actor actor )
+void SceneHolder::Remove(Dali::Actor actor)
{
- if ( mScene )
+ if(mScene)
{
- mScene.Remove( actor );
+ mScene.Remove(actor);
}
}
void SceneHolder::SetSurface(Dali::RenderSurfaceInterface* surface)
{
- mSurface.reset( surface );
+ mSurface.reset(surface);
mScene.SurfaceReplaced();
InitializeDpi();
- mSurface->SetAdaptor( *mAdaptor );
- mSurface->SetScene( mScene );
+ mSurface->SetAdaptor(*mAdaptor);
+ mSurface->SetScene(mScene);
- OnSurfaceSet( surface );
+ OnSurfaceSet(surface);
}
void SceneHolder::SurfaceResized()
{
PositionSize surfacePositionSize = mSurface->GetPositionSize();
- mScene.SurfaceResized( static_cast<float>( surfacePositionSize.width ), static_cast<float>( surfacePositionSize.height ) );
+ mScene.SurfaceResized(static_cast<float>(surfacePositionSize.width), static_cast<float>(surfacePositionSize.height));
mSurface->SetFullSwapNextFrame();
}
return mSurface.get();
}
-void SceneHolder::SetBackgroundColor( const Vector4& color )
+void SceneHolder::SetBackgroundColor(const Vector4& color)
{
- if( mScene )
+ if(mScene)
{
- mScene.SetBackgroundColor( color );
+ mScene.SetBackgroundColor(color);
mSurface->SetFullSwapNextFrame();
}
void SceneHolder::SetAdaptor(Dali::Adaptor& adaptor)
{
// Avoid doing this more than once
- if( mAdaptorStarted )
+ if(mAdaptorStarted)
{
return;
}
// Create the scene
PositionSize surfacePositionSize = mSurface->GetPositionSize();
- mScene = Dali::Integration::Scene::New( Size(static_cast<float>( surfacePositionSize.width ), static_cast<float>( surfacePositionSize.height )) );
+ mScene = Dali::Integration::Scene::New(Size(static_cast<float>(surfacePositionSize.width), static_cast<float>(surfacePositionSize.height)));
- Internal::Adaptor::Adaptor& adaptorImpl = Internal::Adaptor::Adaptor::GetImplementation( adaptor );
- mAdaptor = &adaptorImpl;
+ Internal::Adaptor::Adaptor& adaptorImpl = Internal::Adaptor::Adaptor::GetImplementation(adaptor);
+ mAdaptor = &adaptorImpl;
// Create an observer for the adaptor lifecycle
- mAdaptor->AddObserver( *mLifeCycleObserver );
+ mAdaptor->AddObserver(*mLifeCycleObserver);
InitializeDpi();
- mSurface->SetAdaptor( *mAdaptor );
- mSurface->SetScene( mScene );
+ mSurface->SetAdaptor(*mAdaptor);
+ mSurface->SetScene(mScene);
- OnAdaptorSet( adaptor );
+ OnAdaptorSet(adaptor);
}
void SceneHolder::Pause()
OnResume();
}
-void SceneHolder::FeedTouchPoint( Dali::Integration::Point& point, int timeStamp )
+void SceneHolder::FeedTouchPoint(Dali::Integration::Point& point, int timeStamp)
{
- if( timeStamp < 1 )
+ if(timeStamp < 1)
{
timeStamp = GetCurrentMilliSeconds();
}
- RecalculateTouchPosition( point );
+ RecalculateTouchPosition(point);
- Integration::TouchEvent touchEvent;
- Integration::HoverEvent hoverEvent;
+ Integration::TouchEvent touchEvent;
+ Integration::HoverEvent hoverEvent;
Integration::TouchEventCombiner::EventDispatchType type = mCombiner.GetNextTouchEvent(point, timeStamp, touchEvent, hoverEvent);
- if( type != Integration::TouchEventCombiner::DISPATCH_NONE )
+ if(type != Integration::TouchEventCombiner::DISPATCH_NONE)
{
- DALI_LOG_INFO( gSceneHolderLogFilter, Debug::Verbose, "%d: Device %d: Button state %d (%.2f, %.2f)\n", timeStamp, point.GetDeviceId(), point.GetState(), point.GetScreenPosition().x, point.GetScreenPosition().y );
+ DALI_LOG_INFO(gSceneHolderLogFilter, Debug::Verbose, "%d: Device %d: Button state %d (%.2f, %.2f)\n", timeStamp, point.GetDeviceId(), point.GetState(), point.GetScreenPosition().x, point.GetScreenPosition().y);
// Signals can be emitted while processing core events, and the scene holder could be deleted in the signal callback.
// Keep the handle alive until the core events are processed.
- Dali::BaseHandle sceneHolder( this );
+ Dali::BaseHandle sceneHolder(this);
// First the touch and/or hover event & related gesture events are queued
- if( type == Integration::TouchEventCombiner::DISPATCH_TOUCH || type == Integration::TouchEventCombiner::DISPATCH_BOTH )
+ if(type == Integration::TouchEventCombiner::DISPATCH_TOUCH || type == Integration::TouchEventCombiner::DISPATCH_BOTH)
{
- mScene.QueueEvent( touchEvent );
+ mScene.QueueEvent(touchEvent);
}
- if( type == Integration::TouchEventCombiner::DISPATCH_HOVER || type == Integration::TouchEventCombiner::DISPATCH_BOTH )
+ if(type == Integration::TouchEventCombiner::DISPATCH_HOVER || type == Integration::TouchEventCombiner::DISPATCH_BOTH)
{
- mScene.QueueEvent( hoverEvent );
+ mScene.QueueEvent(hoverEvent);
}
// Next the events are processed with a single call into Core
}
}
-void SceneHolder::FeedWheelEvent( Dali::Integration::WheelEvent& wheelEvent )
+void SceneHolder::FeedWheelEvent(Dali::Integration::WheelEvent& wheelEvent)
{
// Signals can be emitted while processing core events, and the scene holder could be deleted in the signal callback.
// Keep the handle alive until the core events are processed.
- Dali::BaseHandle sceneHolder( this );
+ Dali::BaseHandle sceneHolder(this);
- mScene.QueueEvent( wheelEvent );
+ mScene.QueueEvent(wheelEvent);
mAdaptor->ProcessCoreEvents();
}
-void SceneHolder::FeedKeyEvent( Dali::Integration::KeyEvent& keyEvent )
+void SceneHolder::FeedKeyEvent(Dali::Integration::KeyEvent& keyEvent)
{
Dali::PhysicalKeyboard physicalKeyboard = PhysicalKeyboard::Get();
- if( physicalKeyboard )
+ if(physicalKeyboard)
{
- if( ! KeyLookup::IsDeviceButton( keyEvent.keyName.c_str() ) )
+ if(!KeyLookup::IsDeviceButton(keyEvent.keyName.c_str()))
{
- GetImplementation( physicalKeyboard ).KeyReceived( keyEvent.time > 1 );
+ GetImplementation(physicalKeyboard).KeyReceived(keyEvent.time > 1);
}
}
// Signals can be emitted while processing core events, and the scene holder could be deleted in the signal callback.
// Keep the handle alive until the core events are processed.
- Dali::BaseHandle sceneHolder( this );
+ Dali::BaseHandle sceneHolder(this);
// Create send KeyEvent to Core.
- mScene.QueueEvent( keyEvent );
+ mScene.QueueEvent(keyEvent);
mAdaptor->ProcessCoreEvents();
}
-void SceneHolder::AddFrameRenderedCallback( std::unique_ptr< CallbackBase > callback, int32_t frameId )
+void SceneHolder::AddFrameRenderedCallback(std::unique_ptr<CallbackBase> callback, int32_t frameId)
{
- mScene.AddFrameRenderedCallback( std::move( callback ), frameId );
+ mScene.AddFrameRenderedCallback(std::move(callback), frameId);
- DALI_LOG_INFO( gSceneHolderLogFilter, Debug::General, "SceneHolder::AddFrameRenderedCallback:: Added [%d]\n", frameId );
+ DALI_LOG_INFO(gSceneHolderLogFilter, Debug::General, "SceneHolder::AddFrameRenderedCallback:: Added [%d]\n", frameId);
}
-void SceneHolder::AddFramePresentedCallback( std::unique_ptr< CallbackBase > callback, int32_t frameId )
+void SceneHolder::AddFramePresentedCallback(std::unique_ptr<CallbackBase> callback, int32_t frameId)
{
- mScene.AddFramePresentedCallback( std::move( callback ), frameId );
+ mScene.AddFramePresentedCallback(std::move(callback), frameId);
- DALI_LOG_INFO( gSceneHolderLogFilter, Debug::General, "SceneHolder::AddFramePresentedCallback:: Added [%d]\n", frameId );
+ DALI_LOG_INFO(gSceneHolderLogFilter, Debug::General, "SceneHolder::AddFramePresentedCallback:: Added [%d]\n", frameId);
}
-Dali::Integration::SceneHolder SceneHolder::Get( Dali::Actor actor )
+Dali::Integration::SceneHolder SceneHolder::Get(Dali::Actor actor)
{
SceneHolder* sceneHolderImpl = nullptr;
- if ( Internal::Adaptor::Adaptor::IsAvailable() )
+ if(Internal::Adaptor::Adaptor::IsAvailable())
{
- Dali::Internal::Adaptor::Adaptor& adaptor = Internal::Adaptor::Adaptor::GetImplementation( Internal::Adaptor::Adaptor::Get() );
- sceneHolderImpl = adaptor.GetWindow( actor );
+ Dali::Internal::Adaptor::Adaptor& adaptor = Internal::Adaptor::Adaptor::GetImplementation(Internal::Adaptor::Adaptor::Get());
+ sceneHolderImpl = adaptor.GetWindow(actor);
}
- return Dali::Integration::SceneHolder( sceneHolderImpl );
+ return Dali::Integration::SceneHolder(sceneHolderImpl);
}
void SceneHolder::Reset()
// Any touch listeners should be told of the interruption.
Integration::TouchEvent event;
- Integration::Point point;
- point.SetState( PointState::INTERRUPTED );
- event.AddPoint( point );
+ Integration::Point point;
+ point.SetState(PointState::INTERRUPTED);
+ event.AddPoint(point);
// First the touch event & related gesture events are queued
- mScene.QueueEvent( event );
+ mScene.QueueEvent(event);
// Next the events are processed with a single call into Core
mAdaptor->ProcessCoreEvents();
unsigned int dpiHorizontal, dpiVertical;
dpiHorizontal = dpiVertical = 0;
- mSurface->GetDpi( dpiHorizontal, dpiVertical );
- mScene.SetDpi( Vector2( static_cast<float>( dpiHorizontal ), static_cast<float>( dpiVertical ) ) );
+ mSurface->GetDpi(dpiHorizontal, dpiVertical);
+ mScene.SetDpi(Vector2(static_cast<float>(dpiHorizontal), static_cast<float>(dpiVertical)));
- mDpi.SetX( dpiHorizontal );
- mDpi.SetY( dpiVertical );
+ mDpi.SetX(dpiHorizontal);
+ mDpi.SetY(dpiVertical);
}
-}// Adaptor
+} // namespace Adaptor
-}// Internal
+} // namespace Internal
-} // Dali
+} // namespace Dali
*/
// EXTERNAL INCLUDES
-#include <memory>
-#include <vector>
-#include <atomic>
-#include <dali/public-api/object/base-object.h>
-#include <dali/public-api/common/intrusive-ptr.h>
-#include <dali/public-api/math/uint-16-pair.h>
-#include <dali/integration-api/scene.h>
#include <dali/integration-api/events/key-event-integ.h>
#include <dali/integration-api/events/point.h>
#include <dali/integration-api/events/touch-event-combiner.h>
+#include <dali/integration-api/scene.h>
+#include <dali/public-api/common/intrusive-ptr.h>
+#include <dali/public-api/math/uint-16-pair.h>
+#include <dali/public-api/object/base-object.h>
+#include <atomic>
+#include <memory>
+#include <vector>
// INTERNAL INCLUDES
#include <dali/integration-api/adaptor-framework/render-surface-interface.h>
namespace Dali
{
-
class Any;
class Adaptor;
class Actor;
namespace Integration
{
-
class Scene;
struct Point;
struct KeyEvent;
struct WheelEvent;
-}
+} // namespace Integration
namespace Internal
{
-
namespace Adaptor
{
-
class Adaptor;
class SceneHolder;
-using SceneHolderPtr = IntrusivePtr< SceneHolder >;
+using SceneHolderPtr = IntrusivePtr<SceneHolder>;
/**
* @brief SceneHolder creates a Scene for rendering.
*/
class DALI_ADAPTOR_API SceneHolder : public BaseObject
{
-
public:
-
/**
* @copydoc Dali::Integration::SceneHolder::Add
*/
- void Add( Dali::Actor actor );
+ void Add(Dali::Actor actor);
/**
* @copydoc Dali::Integration::SceneHolder::Remove
*/
- void Remove( Dali::Actor actor );
+ void Remove(Dali::Actor actor);
/**
* @copydoc Dali::Integration::SceneHolder::GetRootLayer
* @brief Set the render surface
* @param[in] surface The render surface
*/
- void SetSurface( Dali::RenderSurfaceInterface* surface );
+ void SetSurface(Dali::RenderSurfaceInterface* surface);
/**
* @brief Called when the surface set is resized.
* @brief Set the adaptor to the scene holder
* @param[in] adaptor An initialized adaptor
*/
- void SetAdaptor( Dali::Adaptor& adaptor );
+ void SetAdaptor(Dali::Adaptor& adaptor);
/**
* @copydoc Dali::Integration::SceneHolder::SetBackgroundColor
*/
- void SetBackgroundColor( const Dali::Vector4& color );
+ void SetBackgroundColor(const Dali::Vector4& color);
/**
* @copydoc Dali::Integration::SceneHolder::GetBackgroundColor
*
* @return true if this scene holder is being deleted in the event thread, or false if not.
*/
- bool IsBeingDeleted() const { return mIsBeingDeleted; }
+ bool IsBeingDeleted() const
+ {
+ return mIsBeingDeleted;
+ }
/**
* @copydoc Dali::Integration::SceneHolder::FeedTouchPoint
*/
- void FeedTouchPoint( Dali::Integration::Point& point, int timeStamp );
+ void FeedTouchPoint(Dali::Integration::Point& point, int timeStamp);
/**
* @copydoc Dali::Integration::SceneHolder::FeedWheelEvent
*/
- void FeedWheelEvent( Dali::Integration::WheelEvent& wheelEvent );
+ void FeedWheelEvent(Dali::Integration::WheelEvent& wheelEvent);
/**
* @copydoc Dali::Integration::SceneHolder::FeedKeyEvent
*/
- void FeedKeyEvent( Dali::Integration::KeyEvent& keyEvent );
+ void FeedKeyEvent(Dali::Integration::KeyEvent& keyEvent);
/**
* @brief Adds a callback that is called when the frame rendering is done by the graphics driver.
*
* @note Ownership of the callback is passed onto this class.
*/
- void AddFrameRenderedCallback( std::unique_ptr< CallbackBase > callback, int32_t frameId );
+ void AddFrameRenderedCallback(std::unique_ptr<CallbackBase> callback, int32_t frameId);
/**
* @brief Adds a callback that is called when the frame rendering is done by the graphics driver.
*
* @note Ownership of the callback is passed onto this class.
*/
- void AddFramePresentedCallback( std::unique_ptr< CallbackBase > callback, int32_t frameId );
+ void AddFramePresentedCallback(std::unique_ptr<CallbackBase> callback, int32_t frameId);
/**
* @copydoc Dali::Integration::SceneHolder::Get()
*/
- static Dali::Integration::SceneHolder Get( Dali::Actor actor );
+ static Dali::Integration::SceneHolder Get(Dali::Actor actor);
/**
* @copydoc Dali::Integration::SceneHolder::KeyEventSignal()
*/
- Dali::Integration::SceneHolder::KeyEventSignalType& KeyEventSignal() { return mScene.KeyEventSignal(); }
+ Dali::Integration::SceneHolder::KeyEventSignalType& KeyEventSignal()
+ {
+ return mScene.KeyEventSignal();
+ }
/**
* @copydoc Dali::Integration::SceneHolder::KeyEventGeneratedSignal()
*/
- Dali::Integration::SceneHolder::KeyEventGeneratedSignalType& KeyEventGeneratedSignal() { return mScene.KeyEventGeneratedSignal(); }
+ Dali::Integration::SceneHolder::KeyEventGeneratedSignalType& KeyEventGeneratedSignal()
+ {
+ return mScene.KeyEventGeneratedSignal();
+ }
/**
* @copydoc Dali::Integration::SceneHolder::TouchedSignal()
*/
- Dali::Integration::SceneHolder::TouchEventSignalType& TouchedSignal() { return mScene.TouchedSignal(); }
+ Dali::Integration::SceneHolder::TouchEventSignalType& TouchedSignal()
+ {
+ return mScene.TouchedSignal();
+ }
/**
* @copydoc Dali::Integration::SceneHolder::WheelEventSignal()
*/
- Dali::Integration::SceneHolder::WheelEventSignalType& WheelEventSignal() { return mScene.WheelEventSignal(); }
+ Dali::Integration::SceneHolder::WheelEventSignalType& WheelEventSignal()
+ {
+ return mScene.WheelEventSignal();
+ }
public: // The following methods can be overridden if required
-
/**
* @brief Returns whether the Scene is visible or not.
* @return True if the Scene is visible, false otherwise.
virtual bool IsVisible() const;
public: // The following methods must be overridden
-
/**
* @copydoc Dali::Integration::SceneHolder::GetNativeHandle
*/
virtual Dali::Any GetNativeHandle() const = 0;
protected:
-
// Constructor
SceneHolder();
~SceneHolder() override;
private: // The following methods can be overridden if required
-
/**
* @brief Called by the base class to inform deriving classes that the adaptor has been set.
* @param[in] adaptor The adaptor
*/
- virtual void OnAdaptorSet( Dali::Adaptor& adaptor ) {};
+ virtual void OnAdaptorSet(Dali::Adaptor& adaptor){};
/**
* @brief Called by the base class to inform deriving classes that a new surface has been set.
* @param[in] surface The new render surface
*/
- virtual void OnSurfaceSet( Dali::RenderSurfaceInterface* surface ) {};
+ virtual void OnSurfaceSet(Dali::RenderSurfaceInterface* surface){};
/**
* @brief Called by the base class to inform deriving classes that we are being paused.
*/
- virtual void OnPause() {};
+ virtual void OnPause(){};
/**
* @brief Called by the base class to inform deriving classes that we are resuming from a paused state.
*/
- virtual void OnResume() {};
+ virtual void OnResume(){};
/**
* Recalculate the touch position if required
* @param[in,out] point The touch point
*/
- virtual void RecalculateTouchPosition( Integration::Point& point ) {};
+ virtual void RecalculateTouchPosition(Integration::Point& point){};
private:
-
/**
* Resets the event handling.
*/
void InitializeDpi();
private:
-
- static uint32_t mSceneHolderCounter; ///< A counter to track the SceneHolder creation
+ static uint32_t mSceneHolderCounter; ///< A counter to track the SceneHolder creation
class SceneHolderLifeCycleObserver;
- std::unique_ptr< SceneHolderLifeCycleObserver > mLifeCycleObserver; ///< The adaptor life cycle observer
+ std::unique_ptr<SceneHolderLifeCycleObserver> mLifeCycleObserver; ///< The adaptor life cycle observer
protected:
+ uint32_t mId; ///< A unique ID to identify the SceneHolder starting from 0
+ Dali::Integration::Scene mScene; ///< The Scene
+ std::string mName; ///< The name of the SceneHolder
- uint32_t mId; ///< A unique ID to identify the SceneHolder starting from 0
- Dali::Integration::Scene mScene; ///< The Scene
- std::string mName; ///< The name of the SceneHolder
-
- std::unique_ptr< Dali::RenderSurfaceInterface > mSurface; ///< The window rendering surface
- Adaptor* mAdaptor; ///< The adaptor
-
- Dali::Integration::TouchEventCombiner mCombiner; ///< Combines multi-touch events.
+ std::unique_ptr<Dali::RenderSurfaceInterface> mSurface; ///< The window rendering surface
+ Adaptor* mAdaptor; ///< The adaptor
+ Dali::Integration::TouchEventCombiner mCombiner; ///< Combines multi-touch events.
- Uint16Pair mDpi; ///< The DPI for this SceneHolder.
+ Uint16Pair mDpi; ///< The DPI for this SceneHolder.
- std::atomic<bool> mIsBeingDeleted; ///< This is set only from the event thread and read only from the render thread
+ std::atomic<bool> mIsBeingDeleted; ///< This is set only from the event thread and read only from the render thread
- bool mAdaptorStarted:1; ///< Whether the adaptor has started or not
- bool mVisible:1; ///< Whether the scene is visible or not
+ bool mAdaptorStarted : 1; ///< Whether the adaptor has started or not
+ bool mVisible : 1; ///< Whether the scene is visible or not
};
-} // Adaptor
+} // namespace Adaptor
-} // Internal
+} // namespace Internal
// Get impl of handle
-inline Internal::Adaptor::SceneHolder& GetImplementation( Dali::Integration::SceneHolder& sceneHolder )
+inline Internal::Adaptor::SceneHolder& GetImplementation(Dali::Integration::SceneHolder& sceneHolder)
{
- DALI_ASSERT_ALWAYS( sceneHolder && "SceneHolder handle is empty" );
+ DALI_ASSERT_ALWAYS(sceneHolder && "SceneHolder handle is empty");
Dali::RefObject& object = sceneHolder.GetBaseObject();
- return static_cast<Internal::Adaptor::SceneHolder&>( object );
+ return static_cast<Internal::Adaptor::SceneHolder&>(object);
}
-inline const Internal::Adaptor::SceneHolder& GetImplementation( const Dali::Integration::SceneHolder& sceneHolder )
+inline const Internal::Adaptor::SceneHolder& GetImplementation(const Dali::Integration::SceneHolder& sceneHolder)
{
- DALI_ASSERT_ALWAYS( sceneHolder && "SceneHolder handle is empty" );
+ DALI_ASSERT_ALWAYS(sceneHolder && "SceneHolder handle is empty");
const Dali::RefObject& object = sceneHolder.GetBaseObject();
- return static_cast<const Internal::Adaptor::SceneHolder&>( object );
+ return static_cast<const Internal::Adaptor::SceneHolder&>(object);
}
-} // Dali
+} // namespace Dali
#endif // DALI_INTEGRATION_INTERNAL_SCENEHOLDER_H
#include <dali/integration-api/adaptor-framework/scene-holder.h>
// EXTERNAL INCLUDES
-#include <dali/public-api/events/wheel-event.h>
#include <dali/integration-api/events/key-event-integ.h>
#include <dali/integration-api/events/touch-event-integ.h>
#include <dali/integration-api/events/wheel-event-integ.h>
+#include <dali/public-api/events/wheel-event.h>
// INTERNAL INCLUDES
-#include <dali/public-api/actors/layer.h>
#include <dali/integration-api/adaptor-framework/scene-holder-impl.h>
+#include <dali/public-api/actors/layer.h>
namespace Dali
{
-
namespace Integration
{
-
SceneHolder::SceneHolder()
{
}
{
}
-SceneHolder::SceneHolder( const SceneHolder& handle )
-:BaseHandle(handle)
+SceneHolder::SceneHolder(const SceneHolder& handle)
+: BaseHandle(handle)
{
}
-SceneHolder::SceneHolder( Internal::Adaptor::SceneHolder* internal )
+SceneHolder::SceneHolder(Internal::Adaptor::SceneHolder* internal)
: BaseHandle(internal)
{
}
-SceneHolder& SceneHolder::operator=( const SceneHolder& rhs )
+SceneHolder& SceneHolder::operator=(const SceneHolder& rhs)
{
BaseHandle::operator=(rhs);
return *this;
}
-void SceneHolder::Add( Actor actor )
+void SceneHolder::Add(Actor actor)
{
- GetImplementation(*this).Add( actor );
+ GetImplementation(*this).Add(actor);
}
-void SceneHolder::Remove( Actor actor )
+void SceneHolder::Remove(Actor actor)
{
- GetImplementation(*this).Remove( actor );
+ GetImplementation(*this).Remove(actor);
}
Layer SceneHolder::GetRootLayer() const
return GetImplementation(*this).GetRootLayer();
}
-void SceneHolder::SetBackgroundColor( Vector4 color )
+void SceneHolder::SetBackgroundColor(Vector4 color)
{
- GetImplementation(*this).SetBackgroundColor( color );
+ GetImplementation(*this).SetBackgroundColor(color);
}
Vector4 SceneHolder::GetBackgroundColor() const
return GetImplementation(*this).GetNativeHandle();
}
-void SceneHolder::FeedTouchPoint( Dali::TouchPoint& point, int timeStamp )
+void SceneHolder::FeedTouchPoint(Dali::TouchPoint& point, int timeStamp)
{
- Integration::Point convertedPoint( point );
- GetImplementation(*this).FeedTouchPoint( convertedPoint, timeStamp );
+ Integration::Point convertedPoint(point);
+ GetImplementation(*this).FeedTouchPoint(convertedPoint, timeStamp);
}
-void SceneHolder::FeedWheelEvent( Dali::WheelEvent& wheelEvent )
+void SceneHolder::FeedWheelEvent(Dali::WheelEvent& wheelEvent)
{
- Integration::WheelEvent event( static_cast< Integration::WheelEvent::Type >( wheelEvent.GetType() ), wheelEvent.GetDirection(), wheelEvent.GetModifiers(), wheelEvent.GetPoint(), wheelEvent.GetDelta(), wheelEvent.GetTime() );
- GetImplementation(*this).FeedWheelEvent( event );
+ Integration::WheelEvent event(static_cast<Integration::WheelEvent::Type>(wheelEvent.GetType()), wheelEvent.GetDirection(), wheelEvent.GetModifiers(), wheelEvent.GetPoint(), wheelEvent.GetDelta(), wheelEvent.GetTime());
+ GetImplementation(*this).FeedWheelEvent(event);
}
-void SceneHolder::FeedKeyEvent( Dali::KeyEvent& keyEvent )
+void SceneHolder::FeedKeyEvent(Dali::KeyEvent& keyEvent)
{
- Integration::KeyEvent event( keyEvent.GetKeyName(), keyEvent.GetLogicalKey(), keyEvent.GetKeyString(), keyEvent.GetKeyCode(), keyEvent.GetKeyModifier(), keyEvent.GetTime(), static_cast< Integration::KeyEvent::State >( keyEvent.GetState() ), keyEvent.GetCompose(), keyEvent.GetDeviceName(), keyEvent.GetDeviceClass(), keyEvent.GetDeviceSubclass() );
- GetImplementation(*this).FeedKeyEvent( event );
+ Integration::KeyEvent event(keyEvent.GetKeyName(), keyEvent.GetLogicalKey(), keyEvent.GetKeyString(), keyEvent.GetKeyCode(), keyEvent.GetKeyModifier(), keyEvent.GetTime(), static_cast<Integration::KeyEvent::State>(keyEvent.GetState()), keyEvent.GetCompose(), keyEvent.GetDeviceName(), keyEvent.GetDeviceClass(), keyEvent.GetDeviceSubclass());
+ GetImplementation(*this).FeedKeyEvent(event);
}
-SceneHolder SceneHolder::Get( Actor actor )
+SceneHolder SceneHolder::Get(Actor actor)
{
- return Internal::Adaptor::SceneHolder::Get( actor );
+ return Internal::Adaptor::SceneHolder::Get(actor);
}
SceneHolder::KeyEventSignalType& SceneHolder::KeyEventSignal()
return GetImplementation(*this).WheelEventSignal();
}
-}// Integration
+} // namespace Integration
-} // Dali
+} // namespace Dali
// EXTERNAL INCLUDES
#include <dali/public-api/dali-adaptor-common.h>
-#include <dali/public-api/object/base-handle.h>
#include <dali/public-api/math/vector4.h>
+#include <dali/public-api/object/base-handle.h>
#include <dali/public-api/signals/dali-signal.h>
namespace Dali
{
-
class Actor;
class Layer;
class Any;
namespace Internal DALI_INTERNAL
{
-
namespace Adaptor
{
-
class SceneHolder;
}
-}
+} // namespace DALI_INTERNAL
namespace Integration
{
-
/**
* @brief SceneHolder is responsible for creating a Scene for rendering.
*/
class DALI_ADAPTOR_API SceneHolder : public BaseHandle
{
public:
+ typedef Signal<void(const Dali::KeyEvent&)> KeyEventSignalType; ///< Key event signal type
- typedef Signal< void (const Dali::KeyEvent&) > KeyEventSignalType; ///< Key event signal type
-
- typedef Signal< bool (const Dali::KeyEvent&) > KeyEventGeneratedSignalType; ///< Key event generated signal type
+ typedef Signal<bool(const Dali::KeyEvent&)> KeyEventGeneratedSignalType; ///< Key event generated signal type
- typedef Signal< void (const Dali::TouchEvent&) > TouchEventSignalType; ///< Touch signal type
+ typedef Signal<void(const Dali::TouchEvent&)> TouchEventSignalType; ///< Touch signal type
- typedef Signal< void (const Dali::WheelEvent&) > WheelEventSignalType; ///< Touched signal type
+ typedef Signal<void(const Dali::WheelEvent&)> WheelEventSignalType; ///< Touched signal type
/**
* @brief Create an uninitialized SceneHolder handle.
*
* @param [in] handle A reference to the copied handle
*/
- SceneHolder( const SceneHolder& handle );
+ SceneHolder(const SceneHolder& handle);
/**
* @brief This assignment operator is required for (smart) pointer semantics.
* @param [in] rhs A reference to the copied handle
* @return A reference to this
*/
- SceneHolder& operator=( const SceneHolder& rhs );
+ SceneHolder& operator=(const SceneHolder& rhs);
/**
* @brief Adds a child Actor to the SceneHolder.
* @pre The actor has been initialized.
* @pre The actor does not have a parent.
*/
- void Add( Actor actor );
+ void Add(Actor actor);
/**
* @brief Removes a child Actor from the SceneHolder.
* @param[in] actor The child
* @pre The actor has been added to the SceneHolder.
*/
- void Remove( Actor actor );
+ void Remove(Actor actor);
/**
* @brief Returns the Scene's Root Layer.
*
* @param[in] color The new background color
*/
- void SetBackgroundColor( Vector4 color );
+ void SetBackgroundColor(Vector4 color);
/**
* @brief Gets the background color.
* @param[in] point The touch point
* @param[in] timeStamp The time stamp
*/
- void FeedTouchPoint( Dali::TouchPoint& point, int timeStamp );
+ void FeedTouchPoint(Dali::TouchPoint& point, int timeStamp);
/**
* @brief Feed (Send) wheel event to core
* @param[in] wheelEvent The wheel event
*/
- void FeedWheelEvent( Dali::WheelEvent& wheelEvent );
+ void FeedWheelEvent(Dali::WheelEvent& wheelEvent);
/**
* @brief Feed (Send) key event to core
* @param[in] keyEvent The key event holding the key information.
*/
- void FeedKeyEvent( Dali::KeyEvent& keyEvent );
+ void FeedKeyEvent(Dali::KeyEvent& keyEvent);
/**
* @brief Retrieve the SceneHolder that the given actor is added to.
* @param[in] actor The actor
* @return The SceneHolder the actor is added to or an empty handle if the actor is not added to any SceneHolder.
*/
- static SceneHolder Get( Actor actor );
+ static SceneHolder Get(Actor actor);
/**
* @brief This signal is emitted when key event is received.
WheelEventSignalType& WheelEventSignal();
public: // Not intended for application developers
-
/**
* @brief This constructor is used internally to create additional SceneHolder handles.
*
* @param[in] sceneHolder A pointer to a newly allocated Dali resource
*/
- explicit SceneHolder( Internal::Adaptor::SceneHolder* sceneHolder );
-
+ explicit SceneHolder(Internal::Adaptor::SceneHolder* sceneHolder);
};
} // namespace Integration
#define DALI_INTEGRATION_THREAD_SYNCHRONIZATION_INTERFACE_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*
*/
-
namespace Dali
{
-
/**
* @brief Interface for the ThreadSyncrhonization handler.
*
class ThreadSynchronizationInterface
{
public:
-
/////////////////////////////////////////////////////////////////////////////////////////////////
// Called by the Event Thread if post-rendering is required
/////////////////////////////////////////////////////////////////////////////////////////////////
virtual void PostRenderWaitForCompletion() = 0;
protected:
-
/**
* @brief Protected constructor, no creation through this interface
*/
- ThreadSynchronizationInterface( ) { }
+ ThreadSynchronizationInterface()
+ {
+ }
/**
* Virtual protected destructor, no deletion through this interface
*/
- virtual ~ThreadSynchronizationInterface() { }
+ virtual ~ThreadSynchronizationInterface()
+ {
+ }
private:
-
// Undefined copy constructor.
- ThreadSynchronizationInterface( const ThreadSynchronizationInterface& );
+ ThreadSynchronizationInterface(const ThreadSynchronizationInterface&);
// Undefined assignment operator.
- ThreadSynchronizationInterface& operator=( const ThreadSynchronizationInterface& );
+ ThreadSynchronizationInterface& operator=(const ThreadSynchronizationInterface&);
};
} // namespace Dali
#define DALI_INTEGRATION_TRIGGER_EVENT_FACTORY_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
#include <dali/public-api/signals/callback.h>
// INTERNAL INCLUDES
-#include <dali/public-api/dali-adaptor-common.h>
#include <dali/integration-api/adaptor-framework/trigger-event-interface.h>
+#include <dali/public-api/dali-adaptor-common.h>
namespace Dali
{
-
/**
* @brief Trigger interface factory class
*
class DALI_ADAPTOR_API TriggerEventFactory
{
public:
-
/**
* @copydoc TriggerEventFactoryInterface::CreateTriggerEvent
*/
- static TriggerEventInterface* CreateTriggerEvent( CallbackBase* callback, TriggerEventInterface::Options options );
+ static TriggerEventInterface* CreateTriggerEvent(CallbackBase* callback, TriggerEventInterface::Options options);
/**
* @copydoc TriggerEventFactoryInterface::DestroyTriggerEvent
*/
- static void DestroyTriggerEvent( TriggerEventInterface* triggerEventInterface );
-
+ static void DestroyTriggerEvent(TriggerEventInterface* triggerEventInterface);
};
} // namespace Dali
#define DALI_INTEGRATION_TRIGGER_EVENT_INTERFACE_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*
*/
-
namespace Dali
{
-
/**
* @brief Interface for a trigger event class.
*
*/
class TriggerEventInterface
{
-
public:
-
/**
* @brief trigger event options
*/
enum Options
{
KEEP_ALIVE_AFTER_TRIGGER,
- DELETE_AFTER_TRIGGER, // automatically delete the trigger event object, after Trigger() is called.
+ DELETE_AFTER_TRIGGER, // automatically delete the trigger event object, after Trigger() is called.
};
/**
virtual void Trigger() = 0;
protected:
-
/**
* @brief Constructor
*/
- TriggerEventInterface( )
+ TriggerEventInterface()
{
}
}
private:
-
// Undefined copy constructor.
- TriggerEventInterface( const TriggerEventInterface& );
+ TriggerEventInterface(const TriggerEventInterface&);
// Undefined assignment operator.
- TriggerEventInterface& operator=( const TriggerEventInterface& );
-
-
+ TriggerEventInterface& operator=(const TriggerEventInterface&);
};
} // namespace Dali
#include <dali/public-api/adaptor-framework/application.h>
// EXTERNAL INCLUDES
-#include <dali/public-api/object/object-registry.h>
#include <dali/integration-api/debug.h>
+#include <dali/public-api/object/object-registry.h>
// INTERNAL INCLUDES
#include <dali/internal/adaptor/common/application-impl.h>
namespace Dali
{
-
Application Application::New()
{
- return New( NULL, NULL );
+ return New(NULL, NULL);
}
-Application Application::New( int* argc, char **argv[] )
+Application Application::New(int* argc, char** argv[])
{
Internal::Adaptor::ApplicationPtr internal = Internal::Adaptor::Application::GetPreInitializedApplication();
- if( internal )
+ if(internal)
{
// pre-initialized application
- internal->SetCommandLineOptions( argc, argv );
- if( argc && ( *argc > 0 ) )
+ internal->SetCommandLineOptions(argc, argv);
+ if(argc && (*argc > 0))
{
- internal->GetWindow().SetClass( (*argv)[0], "" );
+ internal->GetWindow().SetClass((*argv)[0], "");
}
- return Application( internal.Get() );
+ return Application(internal.Get());
}
else
{
- internal = Internal::Adaptor::Application::New( argc, argv, "", OPAQUE, PositionSize(),
- Internal::Adaptor::Framework::NORMAL);
+ internal = Internal::Adaptor::Application::New(argc, argv, "", OPAQUE, PositionSize(), Internal::Adaptor::Framework::NORMAL);
return Application(internal.Get());
}
}
-Application Application::New( int* argc, char **argv[], const std::string& stylesheet )
+Application Application::New(int* argc, char** argv[], const std::string& stylesheet)
{
Internal::Adaptor::ApplicationPtr internal = Internal::Adaptor::Application::GetPreInitializedApplication();
- if( internal )
+ if(internal)
{
// pre-initialized application
- internal->SetCommandLineOptions( argc, argv );
- if( argc && ( *argc > 0 ) )
+ internal->SetCommandLineOptions(argc, argv);
+ if(argc && (*argc > 0))
{
- internal->GetWindow().SetClass( (*argv)[0], "" );
+ internal->GetWindow().SetClass((*argv)[0], "");
}
- internal->SetStyleSheet( stylesheet );
+ internal->SetStyleSheet(stylesheet);
- return Application( internal.Get() );
+ return Application(internal.Get());
}
else
{
- internal = Internal::Adaptor::Application::New( argc, argv, stylesheet, OPAQUE, PositionSize(),
- Internal::Adaptor::Framework::NORMAL);
+ internal = Internal::Adaptor::Application::New(argc, argv, stylesheet, OPAQUE, PositionSize(), Internal::Adaptor::Framework::NORMAL);
return Application(internal.Get());
}
}
-Application Application::New( int* argc, char **argv[], const std::string& stylesheet, WINDOW_MODE windowMode )
+Application Application::New(int* argc, char** argv[], const std::string& stylesheet, WINDOW_MODE windowMode)
{
Internal::Adaptor::ApplicationPtr internal = Internal::Adaptor::Application::GetPreInitializedApplication();
- if( internal )
+ if(internal)
{
// pre-initialized application
- internal->SetCommandLineOptions( argc, argv );
- if( argc && ( *argc > 0 ) )
+ internal->SetCommandLineOptions(argc, argv);
+ if(argc && (*argc > 0))
{
- internal->GetWindow().SetClass( (*argv)[0], "" );
+ internal->GetWindow().SetClass((*argv)[0], "");
}
- internal->SetStyleSheet( stylesheet );
+ internal->SetStyleSheet(stylesheet);
- internal->GetWindow().SetTransparency( ( windowMode == Application::OPAQUE ? false : true ) );
+ internal->GetWindow().SetTransparency((windowMode == Application::OPAQUE ? false : true));
- return Application( internal.Get() );
+ return Application(internal.Get());
}
else
{
- internal = Internal::Adaptor::Application::New( argc, argv, stylesheet, windowMode, PositionSize(),
- Internal::Adaptor::Framework::NORMAL);
+ internal = Internal::Adaptor::Application::New(argc, argv, stylesheet, windowMode, PositionSize(), Internal::Adaptor::Framework::NORMAL);
return Application(internal.Get());
}
}
-Application Application::New( int* argc, char **argv[], const std::string& stylesheet, Application::WINDOW_MODE windowMode, PositionSize positionSize )
+Application Application::New(int* argc, char** argv[], const std::string& stylesheet, Application::WINDOW_MODE windowMode, PositionSize positionSize)
{
Internal::Adaptor::ApplicationPtr internal = Internal::Adaptor::Application::GetPreInitializedApplication();
- if( internal )
+ if(internal)
{
// pre-initialized application
- internal->SetCommandLineOptions( argc, argv );
- if( argc && ( *argc > 0 ) )
+ internal->SetCommandLineOptions(argc, argv);
+ if(argc && (*argc > 0))
{
- internal->GetWindow().SetClass( (*argv)[0], "" );
+ internal->GetWindow().SetClass((*argv)[0], "");
}
- internal->SetStyleSheet( stylesheet );
+ internal->SetStyleSheet(stylesheet);
- internal->GetWindow().SetTransparency( ( windowMode == Application::OPAQUE ? false : true ) );
- internal->GetWindow().SetSize( Window::WindowSize( positionSize.width, positionSize.height ) );
- internal->GetWindow().SetPosition( Window::WindowPosition( positionSize.x, positionSize.y ) );
+ internal->GetWindow().SetTransparency((windowMode == Application::OPAQUE ? false : true));
+ internal->GetWindow().SetSize(Window::WindowSize(positionSize.width, positionSize.height));
+ internal->GetWindow().SetPosition(Window::WindowPosition(positionSize.x, positionSize.y));
- return Application( internal.Get() );
+ return Application(internal.Get());
}
else
{
- internal = Internal::Adaptor::Application::New( argc, argv, stylesheet, windowMode, positionSize, Internal::Adaptor::Framework::NORMAL );
- return Application( internal.Get() );
+ internal = Internal::Adaptor::Application::New(argc, argv, stylesheet, windowMode, positionSize, Internal::Adaptor::Framework::NORMAL);
+ return Application(internal.Get());
}
}
{
}
-Application::Application( const Application& copy ) = default;
+Application::Application(const Application& copy) = default;
-Application& Application::operator=( const Application& rhs ) = default;
+Application& Application::operator=(const Application& rhs) = default;
-Application::Application( Application&& rhs ) = default;
+Application::Application(Application&& rhs) = default;
-Application& Application::operator=( Application&& rhs ) = default;
+Application& Application::operator=(Application&& rhs) = default;
void Application::MainLoop()
{
Internal::Adaptor::GetImplementation(*this).Quit();
}
-bool Application::AddIdle( CallbackBase* callback )
+bool Application::AddIdle(CallbackBase* callback)
{
- return Internal::Adaptor::GetImplementation(*this).AddIdle( callback, false );
+ return Internal::Adaptor::GetImplementation(*this).AddIdle(callback, false);
}
Window Application::GetWindow()
return Internal::Adaptor::GetImplementation(*this).ResetSignal();
}
-Application::AppControlSignalType & Application::AppControlSignal()
+Application::AppControlSignalType& Application::AppControlSignal()
{
return Internal::Adaptor::GetImplementation(*this).AppControlSignal();
}
{
}
-
} // namespace Dali
namespace Dali
{
-
class ObjectRegistry;
/**
{
class Application;
}
-}
+} // namespace DALI_INTERNAL
/**
* @brief An Application class object should be created by every application
* that wishes to use Dali.
class DALI_ADAPTOR_API Application : public BaseHandle
{
public:
-
- typedef Signal< void (DeviceStatus::Battery::Status) > LowBatterySignalType; ///< Application device signal type @SINCE_1_2.62
- typedef Signal< void (DeviceStatus::Memory::Status) > LowMemorySignalType; ///< Application device signal type @SINCE_1_2.62
- typedef Signal< void (Application&) > AppSignalType; ///< Application lifecycle signal and system signal callback type @SINCE_1_0.0
- typedef Signal< void (Application&, void *) > AppControlSignalType; ///< Application control signal callback type @SINCE_1_0.0
+ typedef Signal<void(DeviceStatus::Battery::Status)> LowBatterySignalType; ///< Application device signal type @SINCE_1_2.62
+ typedef Signal<void(DeviceStatus::Memory::Status)> LowMemorySignalType; ///< Application device signal type @SINCE_1_2.62
+ typedef Signal<void(Application&)> AppSignalType; ///< Application lifecycle signal and system signal callback type @SINCE_1_0.0
+ typedef Signal<void(Application&, void*)> AppControlSignalType; ///< Application control signal callback type @SINCE_1_0.0
/**
* @brief Enumeration for deciding whether a Dali application window is opaque or transparent.
*/
enum WINDOW_MODE
{
- OPAQUE = 0, ///< The window will be opaque @SINCE_1_0.0
- TRANSPARENT = 1 ///< The window transparency will match the alpha value set in Dali::Stage::SetBackgroundcolor() @SINCE_1_0.0
+ OPAQUE = 0, ///< The window will be opaque @SINCE_1_0.0
+ TRANSPARENT = 1 ///< The window transparency will match the alpha value set in Dali::Stage::SetBackgroundcolor() @SINCE_1_0.0
};
public:
-
/**
* @brief This is the constructor for applications without an argument list.
* @SINCE_1_0.0
* @param[in,out] argv A pointer to the argument list
* @return A handle to the Application
*/
- static Application New( int* argc, char **argv[] );
+ static Application New(int* argc, char** argv[]);
/**
* @brief This is the constructor for applications with a name.
* @return A handle to the Application
* @note If the stylesheet is not specified, then the library's default stylesheet will not be overridden.
*/
- static Application New( int* argc, char **argv[], const std::string& stylesheet );
+ static Application New(int* argc, char** argv[], const std::string& stylesheet);
/**
* @brief This is the constructor for applications with a name.
* @return A handle to the Application
* @note If the stylesheet is not specified, then the library's default stylesheet will not be overridden.
*/
- static Application New( int* argc, char **argv[], const std::string& stylesheet, WINDOW_MODE windowMode );
+ static Application New(int* argc, char** argv[], const std::string& stylesheet, WINDOW_MODE windowMode);
/**
* @brief This is the constructor for applications.
* @return A handle to the Application
* @note If the stylesheet is not specified, then the library's default stylesheet will not be overridden.
*/
- static Application New( int* argc, char **argv[], const std::string& stylesheet, Application::WINDOW_MODE windowMode, PositionSize positionSize );
+ static Application New(int* argc, char** argv[], const std::string& stylesheet, Application::WINDOW_MODE windowMode, PositionSize positionSize);
/**
* @brief Constructs an empty handle.
* @SINCE_1_0.0
* @param[in] application Handle to an object
*/
- Application( const Application& application );
+ Application(const Application& application);
/**
* @brief Assignment operator.
* @param[in] application Handle to an object
* @return A reference to this
*/
- Application& operator=( const Application& application );
+ Application& operator=(const Application& application);
/**
* @brief Move constructor.
* @SINCE_1_9.24
* @param[in] rhs A reference to the moved handle
*/
- Application( Application&& rhs );
+ Application(Application&& rhs);
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this handle
*/
- Application& operator=( Application&& rhs );
+ Application& operator=(Application&& rhs);
/**
* @brief Destructor.
*
* @note Ownership of the callback is passed onto this class.
*/
- bool AddIdle( CallbackBase* callback );
+ bool AddIdle(CallbackBase* callback);
/**
* @brief Retrieves the main window used by the Application class.
*/
ObjectRegistry GetObjectRegistry() const;
-public: // Signals
-
+public: // Signals
/**
* @brief The user should connect to this signal to determine when they should initialize
* their application.
#define DALI_DEVICE_STATUS_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
};
};
-}// namespace DeviceStatus
+} // namespace DeviceStatus
/**
* @}
*/
namespace InputMethod
{
-
/**
* @brief Enumeration for settings that can be changed in the system Input Method.
*
*/
namespace Category
{
-
/**
* @brief Enumeration for Category type.
*
*/
enum Type
{
- PANEL_LAYOUT, ///< Set Keyboard layout @SINCE_1_3.20
- BUTTON_ACTION, ///< Set Button Action @SINCE_1_3.20
- AUTO_CAPITALIZE, ///< Set Auto capitalize of input @SINCE_1_3.20
- VARIATION ///< Set variation @SINCE_1_3.20
+ PANEL_LAYOUT, ///< Set Keyboard layout @SINCE_1_3.20
+ BUTTON_ACTION, ///< Set Button Action @SINCE_1_3.20
+ AUTO_CAPITALIZE, ///< Set Auto capitalize of input @SINCE_1_3.20
+ VARIATION ///< Set variation @SINCE_1_3.20
};
} // namespace Category
*/
namespace PanelLayout
{
-
/**
* @brief Enumeration for PanelLayout type.
*
*/
enum Type
{
- NORMAL, ///< Default layout @SINCE_1_3.20
- NUMBER, ///< Number layout @SINCE_1_3.20
- EMAIL, ///< Email layout @SINCE_1_3.20
- URL, ///< URL layout @SINCE_1_3.20
- PHONENUMBER, ///< Phone Number layout @SINCE_1_3.20
- IP, ///< IP layout @SINCE_1_3.20
- MONTH, ///< Month layout @SINCE_1_3.20
- NUMBER_ONLY, ///< Number Only layout @SINCE_1_3.20
- HEX, ///< Hexadecimal layout @SINCE_1_3.20
- TERMINAL, ///< Command-line terminal layout including ESC, Alt, Ctrl key, so on (no auto-correct, no auto-capitalization) @SINCE_1_3.20
- PASSWORD, ///< Like normal, but no auto-correct, no auto-capitalization etc @SINCE_1_3.20
- DATE_TIME, ///< Date and time layout @SINCE_1_3.20
- EMOTICON ///< Emoticon layout @SINCE_1_3.20
+ NORMAL, ///< Default layout @SINCE_1_3.20
+ NUMBER, ///< Number layout @SINCE_1_3.20
+ EMAIL, ///< Email layout @SINCE_1_3.20
+ URL, ///< URL layout @SINCE_1_3.20
+ PHONENUMBER, ///< Phone Number layout @SINCE_1_3.20
+ IP, ///< IP layout @SINCE_1_3.20
+ MONTH, ///< Month layout @SINCE_1_3.20
+ NUMBER_ONLY, ///< Number Only layout @SINCE_1_3.20
+ HEX, ///< Hexadecimal layout @SINCE_1_3.20
+ TERMINAL, ///< Command-line terminal layout including ESC, Alt, Ctrl key, so on (no auto-correct, no auto-capitalization) @SINCE_1_3.20
+ PASSWORD, ///< Like normal, but no auto-correct, no auto-capitalization etc @SINCE_1_3.20
+ DATE_TIME, ///< Date and time layout @SINCE_1_3.20
+ EMOTICON ///< Emoticon layout @SINCE_1_3.20
};
} // namespace PanelLayout
*/
namespace ButtonAction
{
-
/**
* @brief Enumeration for ButtonAction type.
*
*/
enum Type
{
- DEFAULT, ///< Default action @SINCE_1_3.20
- DONE, ///< Done @SINCE_1_3.20
- GO, ///< Go action @SINCE_1_3.20
- JOIN, ///< Join action @SINCE_1_3.20
- LOGIN, ///< Login action @SINCE_1_3.20
- NEXT, ///< Next action @SINCE_1_3.20
- PREVIOUS, ///< Previous action @SINCE_1_3.20
- SEARCH, ///< Search action @SINCE_1_3.20
- SEND, ///< Send action @SINCE_1_3.20
- SIGNIN, ///< Sign in action @SINCE_1_3.20
- UNSPECIFIED, ///< Unspecified action @SINCE_1_3.20
- NONE ///< Nothing to do @SINCE_1_3.20
+ DEFAULT, ///< Default action @SINCE_1_3.20
+ DONE, ///< Done @SINCE_1_3.20
+ GO, ///< Go action @SINCE_1_3.20
+ JOIN, ///< Join action @SINCE_1_3.20
+ LOGIN, ///< Login action @SINCE_1_3.20
+ NEXT, ///< Next action @SINCE_1_3.20
+ PREVIOUS, ///< Previous action @SINCE_1_3.20
+ SEARCH, ///< Search action @SINCE_1_3.20
+ SEND, ///< Send action @SINCE_1_3.20
+ SIGNIN, ///< Sign in action @SINCE_1_3.20
+ UNSPECIFIED, ///< Unspecified action @SINCE_1_3.20
+ NONE ///< Nothing to do @SINCE_1_3.20
};
} // namespace ButtonAction
-
/**
* @brief Sets Autocapitalization Types.
*
*/
namespace AutoCapital
{
-
/**
* @brief Enumeration for AutoCapital type.
*
} // namespace AutoCapital
-
/////////////////////////// VARIATION based on PANEL_LAYOUT //////////////////////////////////
/**
*/
namespace NormalLayout
{
-
/**
* @brief Enumeration for NormalLayout Variation type.
*
*/
enum Type
{
- NORMAL, ///< The plain normal layout @SINCE_1_3.20
- WITH_FILENAME, ///< Filename layout. Symbols such as '/' should be disabled @SINCE_1_3.20
- WITH_PERSON_NAME ///< The name of a person @SINCE_1_3.20
+ NORMAL, ///< The plain normal layout @SINCE_1_3.20
+ WITH_FILENAME, ///< Filename layout. Symbols such as '/' should be disabled @SINCE_1_3.20
+ WITH_PERSON_NAME ///< The name of a person @SINCE_1_3.20
};
} // namespace NormalLayout
*/
namespace NumberOnlyLayout
{
-
/**
* @brief Enumeration for NumberOnlyLayout Variation type.
*
*/
namespace PasswordLayout
{
-
/**
* @brief Enumeration for PasswordLayout Variation type.
*
*/
enum Type
{
- NORMAL, ///< The normal password layout @SINCE_1_3.20
- WITH_NUMBER_ONLY ///< The password layout to allow only number @SINCE_1_3.20
+ NORMAL, ///< The normal password layout @SINCE_1_3.20
+ WITH_NUMBER_ONLY ///< The password layout to allow only number @SINCE_1_3.20
};
} // namespace PasswordLayout
#define DALI_KEY_GRAB_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
// INTERNAL INCLUDES
-#include <dali/public-api/dali-adaptor-common.h>
#include <dali/public-api/common/dali-vector.h>
+#include <dali/public-api/dali-adaptor-common.h>
// EXTERNAL INCLUDES
#include <dali/public-api/adaptor-framework/key.h>
*/
namespace KeyGrab
{
-
/**
* @brief Grabs the key specified by @a key for @a window only when @a window is the topmost window.
*
* @param[in] daliKey The key code to grab (defined in key.h)
* @return true if the grab succeeds
*/
-DALI_ADAPTOR_API bool GrabKeyTopmost( Window window, Dali::KEY daliKey );
+DALI_ADAPTOR_API bool GrabKeyTopmost(Window window, Dali::KEY daliKey);
/**
* @brief Ungrabs the key specified by @a key for @a window.
* @note If this function is called between key down and up events of a grabbed key,
* an application doesn't receive the key up event.
*/
-DALI_ADAPTOR_API bool UngrabKeyTopmost( Window window, Dali::KEY daliKey );
+DALI_ADAPTOR_API bool UngrabKeyTopmost(Window window, Dali::KEY daliKey);
/**
* @brief Enumeration for key grab mode for platform-level APIs.
*/
enum KeyGrabMode
{
- TOPMOST = 0, ///< Grab a key only when on the top of the grabbing-window stack mode. @SINCE_1_0.0
- SHARED, ///< Grab a key together with the other client window(s) mode. @SINCE_1_0.0
- OVERRIDE_EXCLUSIVE, ///< Grab a key exclusively regardless of the grabbing-window's position on the window stack with the possibility of overriding the grab by the other client window mode. @SINCE_1_0.0
- EXCLUSIVE ///< Grab a key exclusively regardless of the grabbing-window's position on the window stack mode. @SINCE_1_0.0
+ TOPMOST = 0, ///< Grab a key only when on the top of the grabbing-window stack mode. @SINCE_1_0.0
+ SHARED, ///< Grab a key together with the other client window(s) mode. @SINCE_1_0.0
+ OVERRIDE_EXCLUSIVE, ///< Grab a key exclusively regardless of the grabbing-window's position on the window stack with the possibility of overriding the grab by the other client window mode. @SINCE_1_0.0
+ EXCLUSIVE ///< Grab a key exclusively regardless of the grabbing-window's position on the window stack mode. @SINCE_1_0.0
};
/**
* @param[in] grabMode The grab mode for the key
* @return true if the grab succeeds
*/
-DALI_ADAPTOR_API bool GrabKey( Window window, Dali::KEY daliKey, KeyGrabMode grabMode );
+DALI_ADAPTOR_API bool GrabKey(Window window, Dali::KEY daliKey, KeyGrabMode grabMode);
/**
* @PLATFORM
* @note If this function is called between key down and up events of a grabbed key,
* an application doesn't receive the key up event.
*/
-DALI_ADAPTOR_API bool UngrabKey( Window window, Dali::KEY daliKey );
-
+DALI_ADAPTOR_API bool UngrabKey(Window window, Dali::KEY daliKey);
/**
* @PLATFORM
* @param[in] returnVector The Dali::Vector of return boolean values for the results of multiple grab succeeds/fails
* @return bool false when error occurs
*/
-DALI_ADAPTOR_API bool GrabKeyList( Window window, const Dali::Vector<Dali::KEY>& daliKeyVector, const Dali::Vector<KeyGrabMode>& grabModeVector, Dali::Vector<bool>& returnVector);
-
+DALI_ADAPTOR_API bool GrabKeyList(Window window, const Dali::Vector<Dali::KEY>& daliKeyVector, const Dali::Vector<KeyGrabMode>& grabModeVector, Dali::Vector<bool>& returnVector);
/**
* @PLATFORM
* @note If this function is called between key down and up events of a grabbed key,
* an application doesn't receive the key up event.
*/
-DALI_ADAPTOR_API bool UngrabKeyList( Window window, const Dali::Vector<Dali::KEY>& daliKeyVector, Dali::Vector<bool>& returnVector);
-
+DALI_ADAPTOR_API bool UngrabKeyList(Window window, const Dali::Vector<Dali::KEY>& daliKeyVector, Dali::Vector<bool>& returnVector);
} // namespace KeyGrab
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
-bool IsKey( const KeyEvent& keyEvent, KEY daliKey)
+bool IsKey(const KeyEvent& keyEvent, KEY daliKey)
{
- return Internal::Adaptor::KeyLookup::IsKey( keyEvent, daliKey );
+ return Internal::Adaptor::KeyLookup::IsKey(keyEvent, daliKey);
}
-}
+} // namespace Dali
#define DALI_KEYCODE_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
enum KEY
{
- DALI_KEY_INVALID = -1, ///< Invalid key value @SINCE_1_0.0
- DALI_KEY_ESCAPE = 9, ///< Escape key @SINCE_1_0.0
- DALI_KEY_BACKSPACE = 22, ///< Backspace key @SINCE_1_0.0
- DALI_KEY_SHIFT_LEFT = 50, ///< Shift Left key @SINCE_1_0.0
- DALI_KEY_SHIFT_RIGHT = 62, ///< Shift Right key @SINCE_1_0.0
- DALI_KEY_CURSOR_UP = 111, ///< Cursor up key @SINCE_1_0.0
- DALI_KEY_CURSOR_LEFT = 113, ///< Cursor left key @SINCE_1_0.0
- DALI_KEY_CURSOR_RIGHT = 114, ///< Cursor right key @SINCE_1_0.0
- DALI_KEY_CURSOR_DOWN = 116, ///< Cursor down key @SINCE_1_0.0
- DALI_KEY_BACK = 166, ///< Back key @SINCE_1_0.0
- DALI_KEY_CAMERA = 167, ///< Camera key @SINCE_1_0.0
- DALI_KEY_CONFIG = 168, ///< Config key @SINCE_1_0.0
- DALI_KEY_POWER = 169, ///< Power key @SINCE_1_0.0
- DALI_KEY_PAUSE = 170, ///< Pause key @SINCE_1_0.0
- DALI_KEY_CANCEL = 171, ///< Cancel key @SINCE_1_0.0
- DALI_KEY_PLAY_CD = 172, ///< Play CD key @SINCE_1_0.0
- DALI_KEY_STOP_CD = 173, ///< Stop CD key @SINCE_1_0.0
- DALI_KEY_PAUSE_CD = 174, ///< Pause CD key @SINCE_1_0.0
- DALI_KEY_NEXT_SONG = 175, ///< Next song key @SINCE_1_0.0
- DALI_KEY_PREVIOUS_SONG = 176, ///< Previous song key @SINCE_1_0.0
- DALI_KEY_REWIND = 177, ///< Rewind key @SINCE_1_0.0
- DALI_KEY_FASTFORWARD = 178, ///< Fastforward key @SINCE_1_0.0
- DALI_KEY_MEDIA = 179, ///< Media key @SINCE_1_0.0
- DALI_KEY_PLAY_PAUSE = 180, ///< Play pause key @SINCE_1_0.0
- DALI_KEY_MUTE = 181, ///< Mute key @SINCE_1_0.0
- DALI_KEY_MENU = 182, ///< Menu key @SINCE_1_0.0
- DALI_KEY_HOME = 183, ///< Home key @SINCE_1_0.0
- DALI_KEY_HOMEPAGE = 187, ///< Homepage key @SINCE_1_0.0
- DALI_KEY_WEBPAGE = 188, ///< Webpage key @SINCE_1_0.0
- DALI_KEY_MAIL = 189, ///< Mail key @SINCE_1_0.0
- DALI_KEY_SCREENSAVER = 190, ///< Screensaver key @SINCE_1_0.0
- DALI_KEY_BRIGHTNESS_UP = 191, ///< Brightness up key @SINCE_1_0.0
- DALI_KEY_BRIGHTNESS_DOWN = 192, ///< Brightness down key @SINCE_1_0.0
- DALI_KEY_SOFT_KBD = 193, ///< Soft KBD key @SINCE_1_0.0
- DALI_KEY_QUICK_PANEL = 194, ///< Quick panel key @SINCE_1_0.0
- DALI_KEY_TASK_SWITCH = 195, ///< Task switch key @SINCE_1_0.0
- DALI_KEY_APPS = 196, ///< Apps key @SINCE_1_0.0
- DALI_KEY_SEARCH = 197, ///< Search key @SINCE_1_0.0
- DALI_KEY_VOICE = 198, ///< Voice key @SINCE_1_0.0
- DALI_KEY_LANGUAGE = 199, ///< Language key @SINCE_1_0.0
- DALI_KEY_VOLUME_UP = 200, ///< Volume up key @SINCE_1_0.0
- DALI_KEY_VOLUME_DOWN = 201 ///< Volume down key @SINCE_1_0.0
+ DALI_KEY_INVALID = -1, ///< Invalid key value @SINCE_1_0.0
+ DALI_KEY_ESCAPE = 9, ///< Escape key @SINCE_1_0.0
+ DALI_KEY_BACKSPACE = 22, ///< Backspace key @SINCE_1_0.0
+ DALI_KEY_SHIFT_LEFT = 50, ///< Shift Left key @SINCE_1_0.0
+ DALI_KEY_SHIFT_RIGHT = 62, ///< Shift Right key @SINCE_1_0.0
+ DALI_KEY_CURSOR_UP = 111, ///< Cursor up key @SINCE_1_0.0
+ DALI_KEY_CURSOR_LEFT = 113, ///< Cursor left key @SINCE_1_0.0
+ DALI_KEY_CURSOR_RIGHT = 114, ///< Cursor right key @SINCE_1_0.0
+ DALI_KEY_CURSOR_DOWN = 116, ///< Cursor down key @SINCE_1_0.0
+ DALI_KEY_BACK = 166, ///< Back key @SINCE_1_0.0
+ DALI_KEY_CAMERA = 167, ///< Camera key @SINCE_1_0.0
+ DALI_KEY_CONFIG = 168, ///< Config key @SINCE_1_0.0
+ DALI_KEY_POWER = 169, ///< Power key @SINCE_1_0.0
+ DALI_KEY_PAUSE = 170, ///< Pause key @SINCE_1_0.0
+ DALI_KEY_CANCEL = 171, ///< Cancel key @SINCE_1_0.0
+ DALI_KEY_PLAY_CD = 172, ///< Play CD key @SINCE_1_0.0
+ DALI_KEY_STOP_CD = 173, ///< Stop CD key @SINCE_1_0.0
+ DALI_KEY_PAUSE_CD = 174, ///< Pause CD key @SINCE_1_0.0
+ DALI_KEY_NEXT_SONG = 175, ///< Next song key @SINCE_1_0.0
+ DALI_KEY_PREVIOUS_SONG = 176, ///< Previous song key @SINCE_1_0.0
+ DALI_KEY_REWIND = 177, ///< Rewind key @SINCE_1_0.0
+ DALI_KEY_FASTFORWARD = 178, ///< Fastforward key @SINCE_1_0.0
+ DALI_KEY_MEDIA = 179, ///< Media key @SINCE_1_0.0
+ DALI_KEY_PLAY_PAUSE = 180, ///< Play pause key @SINCE_1_0.0
+ DALI_KEY_MUTE = 181, ///< Mute key @SINCE_1_0.0
+ DALI_KEY_MENU = 182, ///< Menu key @SINCE_1_0.0
+ DALI_KEY_HOME = 183, ///< Home key @SINCE_1_0.0
+ DALI_KEY_HOMEPAGE = 187, ///< Homepage key @SINCE_1_0.0
+ DALI_KEY_WEBPAGE = 188, ///< Webpage key @SINCE_1_0.0
+ DALI_KEY_MAIL = 189, ///< Mail key @SINCE_1_0.0
+ DALI_KEY_SCREENSAVER = 190, ///< Screensaver key @SINCE_1_0.0
+ DALI_KEY_BRIGHTNESS_UP = 191, ///< Brightness up key @SINCE_1_0.0
+ DALI_KEY_BRIGHTNESS_DOWN = 192, ///< Brightness down key @SINCE_1_0.0
+ DALI_KEY_SOFT_KBD = 193, ///< Soft KBD key @SINCE_1_0.0
+ DALI_KEY_QUICK_PANEL = 194, ///< Quick panel key @SINCE_1_0.0
+ DALI_KEY_TASK_SWITCH = 195, ///< Task switch key @SINCE_1_0.0
+ DALI_KEY_APPS = 196, ///< Apps key @SINCE_1_0.0
+ DALI_KEY_SEARCH = 197, ///< Search key @SINCE_1_0.0
+ DALI_KEY_VOICE = 198, ///< Voice key @SINCE_1_0.0
+ DALI_KEY_LANGUAGE = 199, ///< Language key @SINCE_1_0.0
+ DALI_KEY_VOLUME_UP = 200, ///< Volume up key @SINCE_1_0.0
+ DALI_KEY_VOLUME_DOWN = 201 ///< Volume down key @SINCE_1_0.0
};
/**
* @param daliKey Dali key enum
* @return @c true if the key is matched, @c false if not
*/
-DALI_ADAPTOR_API bool IsKey( const Dali::KeyEvent& keyEvent, Dali::KEY daliKey);
+DALI_ADAPTOR_API bool IsKey(const Dali::KeyEvent& keyEvent, Dali::KEY daliKey);
/**
* @}
#include <dali/public-api/object/any.h>
// INTERNAL INCLUDES
-#include <dali/internal/imaging/common/native-image-source-impl.h>
#include <dali/internal/imaging/common/native-image-source-factory.h>
+#include <dali/internal/imaging/common/native-image-source-impl.h>
namespace Dali
{
-
-NativeImageSourcePtr NativeImageSource::New( unsigned int width, unsigned int height, ColorDepth depth )
+NativeImageSourcePtr NativeImageSource::New(unsigned int width, unsigned int height, ColorDepth depth)
{
- Any empty;
- NativeImageSourcePtr image = new NativeImageSource( width, height, depth, empty );
+ Any empty;
+ NativeImageSourcePtr image = new NativeImageSource(width, height, depth, empty);
return image;
}
return mImpl->GetNativeImageSource();
}
-NativeImageSourcePtr NativeImageSource::New( Any nativeImageSource )
+NativeImageSourcePtr NativeImageSource::New(Any nativeImageSource)
{
NativeImageSourcePtr image = new NativeImageSource(0, 0, COLOR_DEPTH_DEFAULT, nativeImageSource);
return image;
}
-bool NativeImageSource::GetPixels( std::vector<unsigned char> &pixbuf, unsigned int &width, unsigned int &height, Pixel::Format& pixelFormat ) const
+bool NativeImageSource::GetPixels(std::vector<unsigned char>& pixbuf, unsigned int& width, unsigned int& height, Pixel::Format& pixelFormat) const
{
- return mImpl->GetPixels( pixbuf, width, height, pixelFormat );
+ return mImpl->GetPixels(pixbuf, width, height, pixelFormat);
}
bool NativeImageSource::EncodeToFile(const std::string& filename) const
{
- return mImpl->EncodeToFile( filename );
+ return mImpl->EncodeToFile(filename);
}
-void NativeImageSource::SetSource( Any source )
+void NativeImageSource::SetSource(Any source)
{
- mImpl->SetSource( source );
+ mImpl->SetSource(source);
}
-bool NativeImageSource::IsColorDepthSupported( ColorDepth colorDepth )
+bool NativeImageSource::IsColorDepthSupported(ColorDepth colorDepth)
{
- return mImpl->IsColorDepthSupported( colorDepth );
+ return mImpl->IsColorDepthSupported(colorDepth);
}
bool NativeImageSource::CreateResource()
return mImpl->GetNativeImageInterfaceExtension();
}
-NativeImageSource::NativeImageSource( unsigned int width, unsigned int height, ColorDepth depth, Any nativeImageSource )
+NativeImageSource::NativeImageSource(unsigned int width, unsigned int height, ColorDepth depth, Any nativeImageSource)
{
auto factory = Dali::Internal::Adaptor::GetNativeImageSourceFactory();
- mImpl = factory->CreateNativeImageSource( width, height, depth, nativeImageSource ).release();
+ mImpl = factory->CreateNativeImageSource(width, height, depth, nativeImageSource).release();
}
NativeImageSource::~NativeImageSource()
#define DALI_NATIVE_IMAGE_SOURCE_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
{
class NativeImageSource;
}
-}
+} // namespace DALI_INTERNAL
class NativeImageSource;
/**
class DALI_ADAPTOR_API NativeImageSource : public NativeImageInterface
{
public:
-
- /**
+ /**
* @brief Enumeration for the instance when creating a native image, the color depth has to be specified.
* @SINCE_1_0.0
*/
- enum ColorDepth
- {
- COLOR_DEPTH_DEFAULT, ///< Uses the current screen default depth (recommended) @SINCE_1_0.0
- COLOR_DEPTH_8, ///< 8 bits per pixel @SINCE_1_0.0
- COLOR_DEPTH_16, ///< 16 bits per pixel @SINCE_1_0.0
- COLOR_DEPTH_24, ///< 24 bits per pixel @SINCE_1_0.0
- COLOR_DEPTH_32 ///< 32 bits per pixel @SINCE_1_0.0
- };
+ enum ColorDepth
+ {
+ COLOR_DEPTH_DEFAULT, ///< Uses the current screen default depth (recommended) @SINCE_1_0.0
+ COLOR_DEPTH_8, ///< 8 bits per pixel @SINCE_1_0.0
+ COLOR_DEPTH_16, ///< 16 bits per pixel @SINCE_1_0.0
+ COLOR_DEPTH_24, ///< 24 bits per pixel @SINCE_1_0.0
+ COLOR_DEPTH_32 ///< 32 bits per pixel @SINCE_1_0.0
+ };
/**
* @brief Creates a new NativeImageSource.
* @param[in] depth color depth of the image
* @return A smart-pointer to a newly allocated image
*/
- static NativeImageSourcePtr New( unsigned int width, unsigned int height, ColorDepth depth );
+ static NativeImageSourcePtr New(unsigned int width, unsigned int height, ColorDepth depth);
/**
* @brief Creates a new NativeImageSource from an existing native image source.
* @return A smart-pointer to a newly allocated image
* @see NativeImageInterface
*/
- static NativeImageSourcePtr New( Any nativeImageSource );
+ static NativeImageSourcePtr New(Any nativeImageSource);
/**
* @brief Retrieves the internal native image.
* @param[out] pixelFormat pixel format used by image
* @return @c true if the pixels were gotten, and @c false otherwise
*/
- bool GetPixels( std::vector<unsigned char>& pixbuf, unsigned int& width, unsigned int& height, Pixel::Format& pixelFormat ) const;
+ bool GetPixels(std::vector<unsigned char>& pixbuf, unsigned int& width, unsigned int& height, Pixel::Format& pixelFormat) const;
/**
* @brief Converts the current pixel contents to either a JPEG or PNG format
* @SINCE_1_1.19
* @param[in] source Any handle with the source
*/
- void SetSource( Any source );
+ void SetSource(Any source);
/**
* @brief Checks if the specified color depth is supported.
* @param[in] colorDepth The color depth to check
* @return @c true if colorDepth is supported, @c false otherwise
*/
- bool IsColorDepthSupported( ColorDepth colorDepth );
+ bool IsColorDepthSupported(ColorDepth colorDepth);
/**
* @copydoc Dali::NativeImageInterface::GetTextureTarget()
*/
const char* GetCustomSamplerTypename() const override;
-private: // native image
-
+private: // native image
/**
* @copydoc Dali::NativeImageInterface::CreateResource()
*/
NativeImageInterface::Extension* GetExtension() override;
private:
-
/// @cond internal
/**
* @brief Private constructor.
* @param[in] depth color depth of the image
* @param[in] nativeImageSource contains either: native image source or is empty
*/
- DALI_INTERNAL NativeImageSource( unsigned int width, unsigned int height, ColorDepth depth, Any nativeImageSource );
+ DALI_INTERNAL NativeImageSource(unsigned int width, unsigned int height, ColorDepth depth, Any nativeImageSource);
/**
* @brief A reference counted object may only be deleted by calling Unreference().
* @SINCE_1_0.0
* @param[in] nativeImageSource A reference to the object to copy
*/
- DALI_INTERNAL NativeImageSource( const NativeImageSource& nativeImageSource );
+ DALI_INTERNAL NativeImageSource(const NativeImageSource& nativeImageSource);
/**
* @brief Undefined assignment operator.
/// @endcond
private:
-
/// @cond internal
Internal::Adaptor::NativeImageSource* mImpl; ///< Implementation pointer
friend class Internal::Adaptor::NativeImageSource;
#define DALI_STYLE_CHANGE_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
namespace StyleChange
{
-
/**
* @brief Enumeration for StyleChange type.
* @SINCE_1_0.0
#include <dali/public-api/adaptor-framework/timer.h>
// INTERNAL INCLUDES
-#include <dali/public-api/dali-adaptor-common.h>
#include <dali/internal/system/common/timer-impl.h>
+#include <dali/public-api/dali-adaptor-common.h>
namespace Dali
{
-
Timer::Timer()
{
}
-Timer Timer::New( unsigned int milliSec )
+Timer Timer::New(unsigned int milliSec)
{
- Internal::Adaptor::TimerPtr internal = Internal::Adaptor::Timer::New( milliSec );
+ Internal::Adaptor::TimerPtr internal = Internal::Adaptor::Timer::New(milliSec);
return Timer(internal.Get());
}
-Timer::Timer( const Timer& copy ) = default;
+Timer::Timer(const Timer& copy) = default;
-Timer& Timer::operator=( const Timer& rhs ) = default;
+Timer& Timer::operator=(const Timer& rhs) = default;
-Timer::Timer( Timer&& rhs ) = default;
+Timer::Timer(Timer&& rhs) = default;
-Timer& Timer::operator=( Timer&& rhs ) = default;
+Timer& Timer::operator=(Timer&& rhs) = default;
Timer::~Timer()
{
}
-Timer Timer::DownCast( BaseHandle handle )
+Timer Timer::DownCast(BaseHandle handle)
{
- return Timer( dynamic_cast<Internal::Adaptor::Timer*>( handle.GetObjectPtr() ) );
+ return Timer(dynamic_cast<Internal::Adaptor::Timer*>(handle.GetObjectPtr()));
}
void Timer::Start()
Internal::Adaptor::GetImplementation(*this).Resume();
}
-void Timer::SetInterval( unsigned int interval )
+void Timer::SetInterval(unsigned int interval)
{
- Internal::Adaptor::GetImplementation(*this).SetInterval( interval, true );
+ Internal::Adaptor::GetImplementation(*this).SetInterval(interval, true);
}
-void Timer::SetInterval( unsigned int interval, bool restart )
+void Timer::SetInterval(unsigned int interval, bool restart)
{
- Internal::Adaptor::GetImplementation(*this).SetInterval( interval, restart );
+ Internal::Adaptor::GetImplementation(*this).SetInterval(interval, restart);
}
unsigned int Timer::GetInterval() const
{
}
-
} // namespace Dali
{
class Timer;
}
-}
+} // namespace DALI_INTERNAL
/**
* @brief Mechanism to issue simple periodic or one-shot events.
*/
class DALI_ADAPTOR_API Timer : public BaseHandle
{
-public: // Signal typedefs
-
- typedef Signal< bool () > TimerSignalType; ///< Timer finished signal callback type @SINCE_1_0.0
+public: // Signal typedefs
+ typedef Signal<bool()> TimerSignalType; ///< Timer finished signal callback type @SINCE_1_0.0
public: // API
-
/**
* @brief Constructor, creates an uninitialized timer.
*
* @param[in] milliSec Interval in milliseconds
* @return A new timer
*/
- static Timer New( unsigned int milliSec );
+ static Timer New(unsigned int milliSec);
/**
* @brief Copy constructor.
* @SINCE_1_0.0
* @param[in] timer The handle to copy. The copied handle will point at the same implementation
*/
- Timer( const Timer& timer );
+ Timer(const Timer& timer);
/**
* @brief Assignment operator.
* as the copied handle
* @return Reference to this timer handle
*/
- Timer& operator=( const Timer& timer );
+ Timer& operator=(const Timer& timer);
/**
* @brief Move constructor.
* @SINCE_1_9.24
* @param[in] rhs A reference to the moved handle
*/
- Timer( Timer&& rhs );
+ Timer(Timer&& rhs);
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this handle
*/
- Timer& operator=( Timer&& rhs );
+ Timer& operator=(Timer&& rhs);
/**
* @brief Destructor.
* @param[in] handle to An object
* @return handle to a Timer object or an uninitialized handle
*/
- static Timer DownCast( BaseHandle handle );
+ static Timer DownCast(BaseHandle handle);
/**
* @brief Starts timer.
* @SINCE_1_0.0
* @param[in] milliSec Interval in milliseconds
*/
- void SetInterval( unsigned int milliSec );
+ void SetInterval(unsigned int milliSec);
/**
* @brief Sets a new interval on the timer with option to restart the timer.
* @param[in] milliSec Interval in milliseconds
* @param[in] restart Flag to set enabled to restart or not.
*/
- void SetInterval( unsigned int milliSec, bool restart );
+ void SetInterval(unsigned int milliSec, bool restart);
/**
* @brief Gets the interval of timer.
bool IsRunning() const;
public: // Signals
-
/**
* @brief Signal emitted after specified time interval.
*
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
TtsPlayer::TtsPlayer()
{
}
{
TtsPlayer ttsPlayer;
- if ( Adaptor::IsAvailable() )
+ if(Adaptor::IsAvailable())
{
- ttsPlayer = Internal::Adaptor::Adaptor::GetImplementation( Adaptor::Get() ).GetTtsPlayer(mode);
+ ttsPlayer = Internal::Adaptor::Adaptor::GetImplementation(Adaptor::Get()).GetTtsPlayer(mode);
}
return ttsPlayer;
{
}
-TtsPlayer::TtsPlayer( const TtsPlayer& copy ) = default;
+TtsPlayer::TtsPlayer(const TtsPlayer& copy) = default;
-TtsPlayer& TtsPlayer::operator=( const TtsPlayer& rhs ) = default;
+TtsPlayer& TtsPlayer::operator=(const TtsPlayer& rhs) = default;
-TtsPlayer::TtsPlayer( TtsPlayer&& rhs ) = default;
+TtsPlayer::TtsPlayer(TtsPlayer&& rhs) = default;
-TtsPlayer& TtsPlayer::operator=( TtsPlayer&& rhs ) = default;
+TtsPlayer& TtsPlayer::operator=(TtsPlayer&& rhs) = default;
void TtsPlayer::Play(const std::string& text)
{
return GetImplementation(*this).StateChangedSignal();
}
-TtsPlayer::TtsPlayer( Internal::Adaptor::TtsPlayer* player )
-: BaseHandle( player )
+TtsPlayer::TtsPlayer(Internal::Adaptor::TtsPlayer* player)
+: BaseHandle(player)
{
}
{
class TtsPlayer;
}
-}
+} // namespace DALI_INTERNAL
/**
* @brief The Text-to-speech (TTS) Player.
class DALI_ADAPTOR_API TtsPlayer : public BaseHandle
{
public: // ENUMs
-
/**
* @brief Enumeration for the instance of TTS mode.
* @SINCE_1_0.0
*/
enum Mode
{
- DEFAULT = 0, ///< Default mode for normal application @SINCE_1_0.0
- NOTIFICATION, ///< Notification mode, such as playing utterance is started or completed @SINCE_1_0.0
+ DEFAULT = 0, ///< Default mode for normal application @SINCE_1_0.0
+ NOTIFICATION, ///< Notification mode, such as playing utterance is started or completed @SINCE_1_0.0
SCREEN_READER, ///< Screen reader mode. To help visually impaired users interact with their devices, screen reader reads text or graphic elements on the screen using the TTS engine. @SINCE_1_0.0
MODE_NUM
};
*/
enum State
{
- UNAVAILABLE = 0, ///< Player is not available @SINCE_1_0.0
- READY, ///< Player is ready to play @SINCE_1_0.0
- PLAYING, ///< Player is playing @SINCE_1_0.0
- PAUSED ///< Player is paused @SINCE_1_0.0
+ UNAVAILABLE = 0, ///< Player is not available @SINCE_1_0.0
+ READY, ///< Player is ready to play @SINCE_1_0.0
+ PLAYING, ///< Player is playing @SINCE_1_0.0
+ PAUSED ///< Player is paused @SINCE_1_0.0
};
public: // Typedefs
-
/**
* @brief Type of signal emitted when the TTS state changes.
* @SINCE_1_0.0
*/
- typedef Signal< void ( const Dali::TtsPlayer::State, const Dali::TtsPlayer::State ) > StateChangedSignalType;
+ typedef Signal<void(const Dali::TtsPlayer::State, const Dali::TtsPlayer::State)> StateChangedSignalType;
public: // API
-
/**
* @brief Creates an uninitialized handle.
*
* @SINCE_1_9.24
* @param[in] rhs A reference to the moved handle
*/
- TtsPlayer( TtsPlayer&& rhs );
+ TtsPlayer(TtsPlayer&& rhs);
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this handle
*/
- TtsPlayer& operator=( TtsPlayer&& rhs );
+ TtsPlayer& operator=(TtsPlayer&& rhs);
/**
* @brief Starts playing the audio data synthesized from the specified text.
Dali::TtsPlayer::StateChangedSignalType& StateChangedSignal();
public: // Not intended for application developers
-
/// @cond internal
/**
* @brief This constructor is used by TtsPlayer::Get().
* @SINCE_1_0.0
* @param[in] ttsPlayer A pointer to the TTS player
*/
- explicit DALI_INTERNAL TtsPlayer( Internal::Adaptor::TtsPlayer* ttsPlayer );
+ explicit DALI_INTERNAL TtsPlayer(Internal::Adaptor::TtsPlayer* ttsPlayer);
/// @endcond
};
namespace Dali
{
-
-WidgetApplication WidgetApplication::New( int* argc, char **argv[], const std::string& stylesheet )
+WidgetApplication WidgetApplication::New(int* argc, char** argv[], const std::string& stylesheet)
{
- Internal::Adaptor::WidgetApplicationPtr internal = Internal::Adaptor::WidgetApplication::New( argc, argv, stylesheet);
+ Internal::Adaptor::WidgetApplicationPtr internal = Internal::Adaptor::WidgetApplication::New(argc, argv, stylesheet);
return WidgetApplication(internal.Get());
}
{
}
-WidgetApplication::WidgetApplication( const WidgetApplication& copy ) = default;
+WidgetApplication::WidgetApplication(const WidgetApplication& copy) = default;
-WidgetApplication& WidgetApplication::operator=( const WidgetApplication& rhs ) = default;
+WidgetApplication& WidgetApplication::operator=(const WidgetApplication& rhs) = default;
-WidgetApplication::WidgetApplication( WidgetApplication&& rhs ) = default;
+WidgetApplication::WidgetApplication(WidgetApplication&& rhs) = default;
-WidgetApplication& WidgetApplication::operator=( WidgetApplication&& rhs ) = default;
+WidgetApplication& WidgetApplication::operator=(WidgetApplication&& rhs) = default;
-void WidgetApplication::RegisterWidgetCreatingFunction( const std::string& widgetName, CreateWidgetFunction createFunction )
+void WidgetApplication::RegisterWidgetCreatingFunction(const std::string& widgetName, CreateWidgetFunction createFunction)
{
- Internal::Adaptor::GetImplementation(*this).RegisterWidgetCreatingFunction( widgetName, createFunction );
+ Internal::Adaptor::GetImplementation(*this).RegisterWidgetCreatingFunction(widgetName, createFunction);
}
WidgetApplication::WidgetApplication(Internal::Adaptor::WidgetApplication* widgetApplication)
namespace Internal DALI_INTERNAL
{
-
namespace Adaptor
{
class WidgetApplication;
}
-}
+} // namespace DALI_INTERNAL
class Widget;
class DALI_ADAPTOR_API WidgetApplication : public Application
{
public:
-
/**
* @brief This is the typedef for Widget creator.
* @SINCE_1_3_5
*/
- typedef Widget(*CreateWidgetFunction)(const std::string&);
+ typedef Widget (*CreateWidgetFunction)(const std::string&);
public:
-
/**
* @brief This is the constructor for WidgetApplications with a name.
*
* @return A handle to the WidgetApplication
* @note If the stylesheet is not specified, then the library's default stylesheet will not be overridden.
*/
- static WidgetApplication New( int* argc, char **argv[], const std::string& stylesheet );
+ static WidgetApplication New(int* argc, char** argv[], const std::string& stylesheet);
/**
* @brief The default constructor.
* @SINCE_1_3_5
* @param[in] widgetApplication Handle to an object
*/
- WidgetApplication( const WidgetApplication& widgetApplication );
+ WidgetApplication(const WidgetApplication& widgetApplication);
/**
* @brief Assignment operator.
* @param[in] widgetApplication Handle to an object
* @return A reference to this
*/
- WidgetApplication& operator=( const WidgetApplication& widgetApplication );
+ WidgetApplication& operator=(const WidgetApplication& widgetApplication);
/**
* @brief Move constructor.
* @SINCE_1_9.24
* @param[in] rhs A reference to the moved handle
*/
- WidgetApplication( WidgetApplication&& rhs );
+ WidgetApplication(WidgetApplication&& rhs);
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this handle
*/
- WidgetApplication& operator=( WidgetApplication&& rhs );
+ WidgetApplication& operator=(WidgetApplication&& rhs);
- /**
+ /**
* @brief Destructor
* @SINCE_1_3_5
*/
* @param[in] widgetName Name of widget
* @param[in] createFunction Function pointer for widget creation.
*/
- void RegisterWidgetCreatingFunction( const std::string& widgetName, CreateWidgetFunction createFunction );
+ void RegisterWidgetCreatingFunction(const std::string& widgetName, CreateWidgetFunction createFunction);
public: // Not intended for application developers
/// @cond internal
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Internal
{
-
namespace Adaptor
{
-
WidgetPtr Widget::New()
{
return new Widget();
}
Widget::Widget()
-: mImpl( nullptr )
+: mImpl(nullptr)
{
}
Widget::~Widget()
{
- if( mImpl != nullptr )
+ if(mImpl != nullptr)
{
delete mImpl;
}
}
-void Widget::OnCreate( const std::string& contentInfo, Dali::Window window )
+void Widget::OnCreate(const std::string& contentInfo, Dali::Window window)
{
}
-void Widget::OnTerminate( const std::string& contentInfo, Dali::Widget::Termination type )
+void Widget::OnTerminate(const std::string& contentInfo, Dali::Widget::Termination type)
{
}
{
}
-void Widget::OnResize( Dali::Window window )
+void Widget::OnResize(Dali::Window window)
{
}
-void Widget::OnUpdate( const std::string& contentInfo, int force )
+void Widget::OnUpdate(const std::string& contentInfo, int force)
{
}
-void Widget::SignalConnected( SlotObserver* slotObserver, CallbackBase* callback )
+void Widget::SignalConnected(SlotObserver* slotObserver, CallbackBase* callback)
{
- mImpl->SignalConnected( slotObserver, callback );
+ mImpl->SignalConnected(slotObserver, callback);
}
-void Widget::SignalDisconnected( SlotObserver* slotObserver, CallbackBase* callback )
+void Widget::SignalDisconnected(SlotObserver* slotObserver, CallbackBase* callback)
{
- mImpl->SignalDisconnected( slotObserver, callback );
+ mImpl->SignalDisconnected(slotObserver, callback);
}
-void Widget::SetContentInfo( const std::string& contentInfo )
+void Widget::SetContentInfo(const std::string& contentInfo)
{
- if( mImpl != nullptr )
+ if(mImpl != nullptr)
{
- mImpl->SetContentInfo( contentInfo );
+ mImpl->SetContentInfo(contentInfo);
}
}
-void Widget::SetImpl( Impl* impl )
+void Widget::SetImpl(Impl* impl)
{
mImpl = impl;
}
return static_cast<const Internal::Adaptor::Widget&>(handle);
}
-} // Adaptor
+} // namespace Adaptor
-} // Internal
+} // namespace Internal
-} // Dali
+} // namespace Dali
#define DALI_INTERNAL_WIDGET_H
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
/**
* @addtogroup dali_adaptor_framework
* @{
namespace Internal
{
-
namespace Adaptor
{
-
class Widget;
typedef IntrusivePtr<Widget> WidgetPtr;
class DALI_ADAPTOR_API Widget : public BaseObject, public ConnectionTrackerInterface
{
public:
-
/**
* @brief Creates a new WidgetImpl instance.
*
* @param[in] contentInfo Information from WidgetView for creating. It contains previous status of widget which is sent by SetContentInfo before.
* @param[in] window Window handle for widget
*/
- virtual void OnCreate( const std::string& contentInfo, Dali::Window window );
+ virtual void OnCreate(const std::string& contentInfo, Dali::Window window);
/**
* @brief The user should override this function to determine when they terminate widget.
* @param[in] contentInfo Data from WidgetView for deleting
* @param[in] type Termination type. When user delete widget view, termination type is PERMANENT.
*/
- virtual void OnTerminate( const std::string& contentInfo, Dali::Widget::Termination type );
+ virtual void OnTerminate(const std::string& contentInfo, Dali::Widget::Termination type);
/**
* @brief The user should override this function to determine when they pause widget.
* @SINCE_1_3_5
* @param[in] window Window handle for widget
*/
- virtual void OnResize( Dali::Window window );
+ virtual void OnResize(Dali::Window window);
/**
* @brief The user should override this function to determine when they update widget.
* @param[in] contentInfo Data from WidgetView for updating
* @param[in] force Although the widget is paused, if it is true, the widget can be updated
*/
- virtual void OnUpdate( const std::string& contentInfo, int force );
+ virtual void OnUpdate(const std::string& contentInfo, int force);
// From ConnectionTrackerInterface
/**
* @copydoc ConnectionTrackerInterface::SignalConnected
*/
- void SignalConnected( SlotObserver* slotObserver, CallbackBase* callback ) override;
+ void SignalConnected(SlotObserver* slotObserver, CallbackBase* callback) override;
/**
* @copydoc ConnectionTrackerInterface::SignalDisconnected
*/
- void SignalDisconnected( SlotObserver* slotObserver, CallbackBase* callback ) override;
+ void SignalDisconnected(SlotObserver* slotObserver, CallbackBase* callback) override;
/**
* @brief Set content info to WidgetView.
* @SINCE_1_3_5
* @param[in] contentInfo Content info is kind of context information which contains current status of widget.
*/
- void SetContentInfo( const std::string& contentInfo );
+ void SetContentInfo(const std::string& contentInfo);
protected:
-
/**
* @brief WidgetImpl constructor
*/
* Set pointer of WidgetImpl Internal.
* @SINCE_1_3_5
*/
- void SetImpl( Impl* impl );
+ void SetImpl(Impl* impl);
private:
Impl* mImpl;
DALI_INTERNAL Widget(const Widget&);
DALI_INTERNAL Widget& operator=(Widget&);
/// @endcond
-
};
/**
* @return Implementation
* @pre handle is initialized and points to a widget
*/
-DALI_ADAPTOR_API Internal::Adaptor::Widget& GetImplementation( Dali::Widget& widget );
+DALI_ADAPTOR_API Internal::Adaptor::Widget& GetImplementation(Dali::Widget& widget);
/**
* @brief Gets implementation from the handle.
* @return Implementation
* @pre Handle is initialized and points to a widget.
*/
-DALI_ADAPTOR_API const Internal::Adaptor::Widget& GetImplementation( const Dali::Widget& widget );
+DALI_ADAPTOR_API const Internal::Adaptor::Widget& GetImplementation(const Dali::Widget& widget);
} // namespace Adaptor
namespace Dali
{
-
Widget Widget::New()
{
Internal::Adaptor::WidgetPtr internal = Internal::Adaptor::Widget::New();
{
}
-Widget::Widget( const Widget& copy ) = default;
+Widget::Widget(const Widget& copy) = default;
-Widget& Widget::operator=( const Widget& rhs ) = default;
+Widget& Widget::operator=(const Widget& rhs) = default;
-Widget::Widget( Widget&& rhs ) = default;
+Widget::Widget(Widget&& rhs) = default;
-Widget& Widget::operator=( Widget&& rhs ) = default;
+Widget& Widget::operator=(Widget&& rhs) = default;
Widget::Widget(Internal::Adaptor::Widget* widget)
: BaseHandle(widget)
namespace Dali
{
-
- /**
+/**
* @addtogroup dali_adaptor_framework
* @{
*/
namespace Internal
{
-
namespace Adaptor
{
class Widget;
}
-}
-
+} // namespace Internal
/**
* @brief Widget class is the base class for custom widget.
class DALI_ADAPTOR_API Widget : public BaseHandle
{
public:
-
/**
* @brief Enumeration class for termination type of widget instance.
* @SINCE_1_3_5
};
public:
-
/**
* @brief This is the constructor for Widget.
* @SINCE_1_3_5
* @SINCE_1_3_5
* @param[in] widget Handle to an object
*/
- Widget( const Widget& widget );
+ Widget(const Widget& widget);
/**
* @brief Assignment operator.
* @param[in] widget Handle to an object
* @return A reference to this
*/
- Widget& operator=( const Widget& widget );
+ Widget& operator=(const Widget& widget);
/**
* @brief Move constructor.
* @SINCE_1_9.24
* @param[in] rhs A reference to the moved handle
*/
- Widget( Widget&& rhs );
+ Widget(Widget&& rhs);
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this handle
*/
- Widget& operator=( Widget&& rhs );
+ Widget& operator=(Widget&& rhs);
/**
* @brief Destructor
#include <dali/integration-api/debug.h>
// INTERNAL INCLUDES
-#include <dali/public-api/actors/actor.h>
-#include <dali/internal/window-system/common/window-impl.h>
#include <dali/internal/window-system/common/orientation-impl.h>
+#include <dali/internal/window-system/common/window-impl.h>
+#include <dali/public-api/actors/actor.h>
namespace Dali
{
-
Window Window::New(PositionSize posSize, const std::string& name, bool isTransparent)
{
return Dali::Window::New(posSize, name, "", isTransparent);
Window newWindow;
const bool isAdaptorAvailable = Dali::Adaptor::IsAvailable();
- bool isNewWindowAllowed = true;
+ bool isNewWindowAllowed = true;
- if (isAdaptorAvailable)
+ if(isAdaptorAvailable)
{
Dali::Adaptor& adaptor = Internal::Adaptor::Adaptor::Get();
- isNewWindowAllowed = Internal::Adaptor::Adaptor::GetImplementation(adaptor).IsMultipleWindowSupported();
+ isNewWindowAllowed = Internal::Adaptor::Adaptor::GetImplementation(adaptor).IsMultipleWindowSupported();
}
- if (isNewWindowAllowed)
+ if(isNewWindowAllowed)
{
Internal::Adaptor::Window* window = Internal::Adaptor::Window::New(posSize, name, className, isTransparent);
Integration::SceneHolder sceneHolder = Integration::SceneHolder(window);
- if (isAdaptorAvailable)
+ if(isAdaptorAvailable)
{
Dali::Adaptor& adaptor = Internal::Adaptor::Adaptor::Get();
Internal::Adaptor::Adaptor::GetImplementation(adaptor).AddWindow(sceneHolder);
{
}
-Window::Window( const Window& copy ) = default;
+Window::Window(const Window& copy) = default;
-Window& Window::operator=( const Window& rhs ) = default;
+Window& Window::operator=(const Window& rhs) = default;
-Window::Window( Window&& rhs ) = default;
+Window::Window(Window&& rhs) = default;
-Window& Window::operator=( Window&& rhs ) = default;
+Window& Window::operator=(Window&& rhs) = default;
-void Window::Add( Dali::Actor actor )
+void Window::Add(Dali::Actor actor)
{
- GetImplementation( *this ).Add( actor );
+ GetImplementation(*this).Add(actor);
}
-void Window::Remove( Dali::Actor actor )
+void Window::Remove(Dali::Actor actor)
{
- GetImplementation( *this ).Remove( actor );
+ GetImplementation(*this).Remove(actor);
}
-void Window::SetBackgroundColor( const Vector4& color )
+void Window::SetBackgroundColor(const Vector4& color)
{
- GetImplementation( *this ).SetBackgroundColor( color );
+ GetImplementation(*this).SetBackgroundColor(color);
}
Vector4 Window::GetBackgroundColor() const
{
- return GetImplementation( *this ).GetBackgroundColor();
+ return GetImplementation(*this).GetBackgroundColor();
}
Layer Window::GetRootLayer() const
{
- return GetImplementation( *this ).GetRootLayer();
+ return GetImplementation(*this).GetRootLayer();
}
uint32_t Window::GetLayerCount() const
{
- return GetImplementation( *this ).GetLayerCount();
+ return GetImplementation(*this).GetLayerCount();
}
-Layer Window::GetLayer( uint32_t depth ) const
+Layer Window::GetLayer(uint32_t depth) const
{
- return GetImplementation( *this ).GetLayer( depth );
+ return GetImplementation(*this).GetLayer(depth);
}
Uint16Pair Window::GetDpi() const
return GetImplementation(*this).GetDpi();
}
-void Window::SetClass( std::string name, std::string klass )
+void Window::SetClass(std::string name, std::string klass)
{
- GetImplementation(*this).SetClass( name, klass );
+ GetImplementation(*this).SetClass(name, klass);
}
void Window::Raise()
GetImplementation(*this).Activate();
}
-void Window::AddAvailableOrientation( WindowOrientation orientation )
+void Window::AddAvailableOrientation(WindowOrientation orientation)
{
- GetImplementation(*this).AddAvailableOrientation( orientation );
+ GetImplementation(*this).AddAvailableOrientation(orientation);
}
-void Window::RemoveAvailableOrientation( WindowOrientation orientation )
+void Window::RemoveAvailableOrientation(WindowOrientation orientation)
{
- GetImplementation(*this).RemoveAvailableOrientation( orientation );
+ GetImplementation(*this).RemoveAvailableOrientation(orientation);
}
-void Window::SetPreferredOrientation( WindowOrientation orientation )
+void Window::SetPreferredOrientation(WindowOrientation orientation)
{
- GetImplementation(*this).SetPreferredOrientation( orientation );
+ GetImplementation(*this).SetPreferredOrientation(orientation);
}
Dali::Window::WindowOrientation Window::GetPreferredOrientation()
return GetImplementation(*this).FocusChangeSignal();
}
-void Window::SetAcceptFocus( bool accept )
+void Window::SetAcceptFocus(bool accept)
{
- GetImplementation(*this).SetAcceptFocus( accept );
+ GetImplementation(*this).SetAcceptFocus(accept);
}
bool Window::IsFocusAcceptable() const
return GetImplementation(*this).GetSupportedAuxiliaryHintCount();
}
-std::string Window::GetSupportedAuxiliaryHint( unsigned int index ) const
+std::string Window::GetSupportedAuxiliaryHint(unsigned int index) const
{
- return GetImplementation(*this).GetSupportedAuxiliaryHint( index );
+ return GetImplementation(*this).GetSupportedAuxiliaryHint(index);
}
-unsigned int Window::AddAuxiliaryHint( const std::string& hint, const std::string& value )
+unsigned int Window::AddAuxiliaryHint(const std::string& hint, const std::string& value)
{
- return GetImplementation(*this).AddAuxiliaryHint( hint, value );
+ return GetImplementation(*this).AddAuxiliaryHint(hint, value);
}
-bool Window::RemoveAuxiliaryHint( unsigned int id )
+bool Window::RemoveAuxiliaryHint(unsigned int id)
{
- return GetImplementation(*this).RemoveAuxiliaryHint( id );
+ return GetImplementation(*this).RemoveAuxiliaryHint(id);
}
-bool Window::SetAuxiliaryHintValue( unsigned int id, const std::string& value )
+bool Window::SetAuxiliaryHintValue(unsigned int id, const std::string& value)
{
- return GetImplementation(*this).SetAuxiliaryHintValue( id, value );
+ return GetImplementation(*this).SetAuxiliaryHintValue(id, value);
}
-std::string Window::GetAuxiliaryHintValue( unsigned int id ) const
+std::string Window::GetAuxiliaryHintValue(unsigned int id) const
{
- return GetImplementation(*this).GetAuxiliaryHintValue( id );
+ return GetImplementation(*this).GetAuxiliaryHintValue(id);
}
-unsigned int Window::GetAuxiliaryHintId( const std::string& hint ) const
+unsigned int Window::GetAuxiliaryHintId(const std::string& hint) const
{
- return GetImplementation(*this).GetAuxiliaryHintId( hint );
+ return GetImplementation(*this).GetAuxiliaryHintId(hint);
}
-void Window::SetInputRegion( const Rect< int >& inputRegion )
+void Window::SetInputRegion(const Rect<int>& inputRegion)
{
- return GetImplementation(*this).SetInputRegion( inputRegion );
+ return GetImplementation(*this).SetInputRegion(inputRegion);
}
-void Window::SetType( Window::Type type )
+void Window::SetType(Window::Type type)
{
- GetImplementation(*this).SetType( type );
+ GetImplementation(*this).SetType(type);
}
Window::Type Window::GetType() const
return GetImplementation(*this).GetType();
}
-bool Window::SetNotificationLevel( Window::NotificationLevel::Type level )
+bool Window::SetNotificationLevel(Window::NotificationLevel::Type level)
{
- return GetImplementation(*this).SetNotificationLevel( level );
+ return GetImplementation(*this).SetNotificationLevel(level);
}
Window::NotificationLevel::Type Window::GetNotificationLevel() const
return GetImplementation(*this).GetNotificationLevel();
}
-void Window::SetOpaqueState( bool opaque )
+void Window::SetOpaqueState(bool opaque)
{
- GetImplementation(*this).SetOpaqueState( opaque );
+ GetImplementation(*this).SetOpaqueState(opaque);
}
bool Window::IsOpaqueState() const
return GetImplementation(*this).GetScreenOffMode();
}
-bool Window::SetBrightness( int brightness )
+bool Window::SetBrightness(int brightness)
{
- return GetImplementation(*this).SetBrightness( brightness );
+ return GetImplementation(*this).SetBrightness(brightness);
}
int Window::GetBrightness() const
return GetImplementation(*this).ResizeSignal();
}
-void Window::SetSize( Window::WindowSize size )
+void Window::SetSize(Window::WindowSize size)
{
- GetImplementation(*this).SetSize( size );
+ GetImplementation(*this).SetSize(size);
}
Window::WindowSize Window::GetSize() const
return GetImplementation(*this).GetSize();
}
-void Window::SetPosition( Window::WindowPosition position )
+void Window::SetPosition(Window::WindowPosition position)
{
- GetImplementation(*this).SetPosition( position );
+ GetImplementation(*this).SetPosition(position);
}
Window::WindowPosition Window::GetPosition() const
return GetImplementation(*this).GetPosition();
}
-void Window::SetTransparency( bool transparent )
+void Window::SetTransparency(bool transparent)
{
- GetImplementation(*this).SetTransparency( transparent );
+ GetImplementation(*this).SetTransparency(transparent);
}
Dali::RenderTaskList Window::GetRenderTaskList()
return GetImplementation(*this).TouchedSignal();
}
-Window::Window( Internal::Adaptor::Window* window )
-: BaseHandle( window )
+Window::Window(Internal::Adaptor::Window* window)
+: BaseHandle(window)
{
}
*/
// EXTERNAL INCLUDES
-#include <string>
#include <dali/public-api/math/rect.h>
#include <dali/public-api/math/uint-16-pair.h>
#include <dali/public-api/math/vector2.h>
#include <dali/public-api/math/vector4.h>
-#include <dali/public-api/object/base-handle.h>
#include <dali/public-api/object/any.h>
+#include <dali/public-api/object/base-handle.h>
#include <dali/public-api/signals/dali-signal.h>
+#include <string>
// INTERNAL INCLUDES
#include <dali/public-api/dali-adaptor-common.h>
{
class Window;
}
-}
+} // namespace DALI_INTERNAL
class DragAndDropDetector;
class Orientation;
class DALI_ADAPTOR_API Window : public BaseHandle
{
public:
+ using WindowSize = Uint16Pair; ///< Window size type @SINCE_1_2.60
+ using WindowPosition = Uint16Pair; ///< Window position type @SINCE_1_2.60
- using WindowSize = Uint16Pair ; ///< Window size type @SINCE_1_2.60
- using WindowPosition = Uint16Pair; ///< Window position type @SINCE_1_2.60
-
- using FocusChangeSignalType = Signal< void (Window,bool) >; ///< Window focus signal type @SINCE_1_4.35
- using ResizeSignalType = Signal< void (Window,WindowSize) >; ///< Window resized signal type @SINCE_1_4.35
- using KeyEventSignalType = Signal< void (const KeyEvent&) >; ///< Key event signal type @SINCE_1_9.21
- using TouchEventSignalType = Signal< void (const TouchEvent&) >; ///< Touch signal type @SINCE_1_9.28
+ using FocusChangeSignalType = Signal<void(Window, bool)>; ///< Window focus signal type @SINCE_1_4.35
+ using ResizeSignalType = Signal<void(Window, WindowSize)>; ///< Window resized signal type @SINCE_1_4.35
+ using KeyEventSignalType = Signal<void(const KeyEvent&)>; ///< Key event signal type @SINCE_1_9.21
+ using TouchEventSignalType = Signal<void(const TouchEvent&)>; ///< Touch signal type @SINCE_1_9.28
public:
-
// Enumerations
/**
*/
enum WindowOrientation
{
- PORTRAIT = 0, ///< Portrait orientation. The height of the display area is greater than the width. @SINCE_1_0.0
- LANDSCAPE = 90, ///< Landscape orientation. A wide view area is needed. @SINCE_1_0.0
- PORTRAIT_INVERSE = 180, ///< Portrait inverse orientation @SINCE_1_0.0
- LANDSCAPE_INVERSE = 270, ///< Landscape inverse orientation @SINCE_1_0.0
- NO_ORIENTATION_PREFERENCE = -1 ///< No orientation. It is used to initialize or unset the preferred orientation. @SINCE_1_4.51
+ PORTRAIT = 0, ///< Portrait orientation. The height of the display area is greater than the width. @SINCE_1_0.0
+ LANDSCAPE = 90, ///< Landscape orientation. A wide view area is needed. @SINCE_1_0.0
+ PORTRAIT_INVERSE = 180, ///< Portrait inverse orientation @SINCE_1_0.0
+ LANDSCAPE_INVERSE = 270, ///< Landscape inverse orientation @SINCE_1_0.0
+ NO_ORIENTATION_PREFERENCE = -1 ///< No orientation. It is used to initialize or unset the preferred orientation. @SINCE_1_4.51
};
/**
*/
enum Type
{
- NORMAL, ///< A default window type. Indicates a normal, top-level window. Almost every window will be created with this type. @SINCE_1_2.60
- NOTIFICATION, ///< A notification window, like a warning about battery life or a new E-Mail received. @SINCE_1_2.60
- UTILITY, ///< A persistent utility window, like a toolbox or palette. @SINCE_1_2.60
- DIALOG ///< Used for simple dialog windows. @SINCE_1_2.60
+ NORMAL, ///< A default window type. Indicates a normal, top-level window. Almost every window will be created with this type. @SINCE_1_2.60
+ NOTIFICATION, ///< A notification window, like a warning about battery life or a new E-Mail received. @SINCE_1_2.60
+ UTILITY, ///< A persistent utility window, like a toolbox or palette. @SINCE_1_2.60
+ DIALOG ///< Used for simple dialog windows. @SINCE_1_2.60
};
/**
*/
enum Type
{
- NONE = -1, ///< No notification level. Default level. This value makes the notification window place in the layer of the normal window. @SINCE_1_2.60
- BASE = 10, ///< Base notification level. @SINCE_1_2.60
- MEDIUM = 20, ///< Higher notification level than base. @SINCE_1_2.60
- HIGH = 30, ///< Higher notification level than medium. @SINCE_1_2.60
- TOP = 40 ///< The highest notification level. @SINCE_1_2.60
+ NONE = -1, ///< No notification level. Default level. This value makes the notification window place in the layer of the normal window. @SINCE_1_2.60
+ BASE = 10, ///< Base notification level. @SINCE_1_2.60
+ MEDIUM = 20, ///< Higher notification level than base. @SINCE_1_2.60
+ HIGH = 30, ///< Higher notification level than medium. @SINCE_1_2.60
+ TOP = 40 ///< The highest notification level. @SINCE_1_2.60
};
};
*/
enum Type
{
- TIMEOUT, ///< The mode which turns the screen off after a timeout. @SINCE_1_2.60
- NEVER, ///< The mode which keeps the screen turned on. @SINCE_1_2.60
+ TIMEOUT, ///< The mode which turns the screen off after a timeout. @SINCE_1_2.60
+ NEVER, ///< The mode which keeps the screen turned on. @SINCE_1_2.60
};
- static constexpr Type DEFAULT { TIMEOUT }; ///< The default mode. @SINCE_1_2.60
+ static constexpr Type DEFAULT{TIMEOUT}; ///< The default mode. @SINCE_1_2.60
};
// Methods
* @SINCE_1_9.24
* @param[in] rhs A reference to the moved handle
*/
- Window( Window&& rhs );
+ Window(Window&& rhs);
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this handle
*/
- Window& operator=( Window&& rhs );
+ Window& operator=(Window&& rhs);
/**
* @brief Adds a child Actor to the Window.
* @pre The actor has been initialized.
* @pre The actor does not have a parent.
*/
- void Add( Actor actor );
+ void Add(Actor actor);
/**
* @brief Removes a child Actor from the Window.
* @param[in] actor The child
* @pre The actor has been added to the stage.
*/
- void Remove( Actor actor );
+ void Remove(Actor actor);
/**
* @brief Sets the background color of the Window.
* @SINCE_1_4.19
* @param[in] color The new background color
*/
- void SetBackgroundColor( const Vector4& color );
+ void SetBackgroundColor(const Vector4& color);
/**
* @brief Gets the background color of the Window.
* @return The layer found at the given depth
* @pre Depth is less than layer count; see GetLayerCount().
*/
- Layer GetLayer( uint32_t depth ) const;
+ Layer GetLayer(uint32_t depth) const;
/**
* @brief Retrieves the DPI of the window.
* @SINCE_1_0.0
* @param[in] orientation The available orientation to add
*/
- void AddAvailableOrientation( WindowOrientation orientation );
+ void AddAvailableOrientation(WindowOrientation orientation);
/**
* @brief Removes an orientation from the list of available orientations.
* @SINCE_1_0.0
* @param[in] orientation The available orientation to remove
*/
- void RemoveAvailableOrientation( WindowOrientation orientation );
+ void RemoveAvailableOrientation(WindowOrientation orientation);
/**
* @brief Sets a preferred orientation.
*
* @note To unset the preferred orientation, orientation should be set NO_ORIENTATION_PREFERENCE.
*/
- void SetPreferredOrientation( WindowOrientation orientation );
+ void SetPreferredOrientation(WindowOrientation orientation);
/**
* @brief Gets the preferred orientation.
* @SINCE_1_2.60
* @param[in] accept If focus is accepted or not. Default is true.
*/
- void SetAcceptFocus( bool accept );
+ void SetAcceptFocus(bool accept);
/**
* @brief Returns whether window accepts focus or not.
* @note The window auxiliary hint is the value which is used to decide which actions should be made available to the user by the window manager.
* If you want to set specific hint to your window, then you should check whether it exists in the supported auxiliary hints.
*/
- std::string GetSupportedAuxiliaryHint( unsigned int index ) const;
+ std::string GetSupportedAuxiliaryHint(unsigned int index) const;
/**
* @brief Creates an auxiliary hint of the window.
* @param[in] value The value string.
* @return The ID of created auxiliary hint, or @c 0 on failure.
*/
- unsigned int AddAuxiliaryHint( const std::string& hint, const std::string& value );
+ unsigned int AddAuxiliaryHint(const std::string& hint, const std::string& value);
/**
* @brief Removes an auxiliary hint of the window.
* @param[in] id The ID of the auxiliary hint.
* @return True if no error occurred, false otherwise.
*/
- bool RemoveAuxiliaryHint( unsigned int id );
+ bool RemoveAuxiliaryHint(unsigned int id);
/**
* @brief Changes a value of the auxiliary hint.
* @param[in] value The value string to be set.
* @return True if no error occurred, false otherwise.
*/
- bool SetAuxiliaryHintValue( unsigned int id, const std::string& value );
+ bool SetAuxiliaryHintValue(unsigned int id, const std::string& value);
/**
* @brief Gets a value of the auxiliary hint.
* @param[in] id The auxiliary hint ID.
* @return The string value of the auxiliary hint ID, or an empty string if none exists.
*/
- std::string GetAuxiliaryHintValue( unsigned int id ) const;
+ std::string GetAuxiliaryHintValue(unsigned int id) const;
/**
* @brief Gets a ID of the auxiliary hint string.
* @param[in] hint The auxiliary hint string.
* @return The ID of the auxiliary hint string, or @c 0 if none exists.
*/
- unsigned int GetAuxiliaryHintId( const std::string& hint ) const;
+ unsigned int GetAuxiliaryHintId(const std::string& hint) const;
/**
* @brief Sets a region to accept input events.
* @SINCE_1_2.60
* @param[in] inputRegion The region to accept input events.
*/
- void SetInputRegion( const Rect< int >& inputRegion );
+ void SetInputRegion(const Rect<int>& inputRegion);
/**
* @brief Sets a window type.
* @param[in] type The window type.
* @remarks The default window type is NORMAL.
*/
- void SetType( Type type );
+ void SetType(Type type);
/**
* @brief Gets a window type.
* @PRIVILEGE_WINDOW_PRIORITY
* @remarks This can be used for a notification type window only. The default level is NotificationLevel::NONE.
*/
- bool SetNotificationLevel( NotificationLevel::Type level );
+ bool SetNotificationLevel(NotificationLevel::Type level);
/**
* @brief Gets a priority level for the specified notification window.
* @remarks This will have no effect on an opaque window.
* It doesn't change transparent window to opaque window but lets the window manager know the visual state of the window.
*/
- void SetOpaqueState( bool opaque );
+ void SetOpaqueState(bool opaque);
/**
* @brief Returns whether a transparent window's visual state is opaque or not.
* @PRIVLEVEL_PUBLIC
* @PRIVILEGE_DISPLAY
*/
- bool SetBrightness( int brightness );
+ bool SetBrightness(int brightness);
/**
* @brief Gets preferred brightness of the window.
* @SINCE_1_2.60
* @param[in] size The new window size
*/
- void SetSize( WindowSize size );
+ void SetSize(WindowSize size);
/**
* @brief Gets a size of the window.
* @SINCE_1_2.60
* @param[in] position The new window position
*/
- void SetPosition( WindowPosition position );
+ void SetPosition(WindowPosition position);
/**
* @brief Gets a position of the window.
* @SINCE_1_2.60
* @param[in] transparent Whether the window is transparent
*/
- void SetTransparency( bool transparent );
+ void SetTransparency(bool transparent);
/**
* @brief Retrieves the list of render-tasks in the window.
RenderTaskList GetRenderTaskList();
public: // Signals
-
/**
* @brief The user should connect to this signal to get a timing when window gains focus or loses focus.
*
* @SINCE_1_0.0
* @param[in] window A pointer to the Window
*/
- explicit DALI_INTERNAL Window( Internal::Adaptor::Window* window );
+ explicit DALI_INTERNAL Window(Internal::Adaptor::Window* window);
/// @endcond
};
namespace Dali
{
-
Capture::Capture()
{
}
{
Internal::Adaptor::CapturePtr internal = Internal::Adaptor::Capture::New();
- return Capture( internal.Get() );
+ return Capture(internal.Get());
}
-Capture Capture::New( Dali::CameraActor cameraActor )
+Capture Capture::New(Dali::CameraActor cameraActor)
{
- Internal::Adaptor::CapturePtr internal = Internal::Adaptor::Capture::New( cameraActor );
+ Internal::Adaptor::CapturePtr internal = Internal::Adaptor::Capture::New(cameraActor);
- return Capture( internal.Get() );
+ return Capture(internal.Get());
}
-Capture Capture::DownCast( BaseHandle handle )
+Capture Capture::DownCast(BaseHandle handle)
{
- return Capture( dynamic_cast< Internal::Adaptor::Capture* >( handle.GetObjectPtr() ) );
+ return Capture(dynamic_cast<Internal::Adaptor::Capture*>(handle.GetObjectPtr()));
}
Capture::~Capture()
{
}
-Capture::Capture( const Capture& copy ) = default;
+Capture::Capture(const Capture& copy) = default;
-Capture& Capture::operator=( const Capture& rhs ) = default;
+Capture& Capture::operator=(const Capture& rhs) = default;
-Capture::Capture( Capture&& rhs ) = default;
+Capture::Capture(Capture&& rhs) = default;
-Capture& Capture::operator=( Capture&& rhs ) = default;
+Capture& Capture::operator=(Capture&& rhs) = default;
-void Capture::Start( Actor source, const Vector2& position, const Vector2& size, const std::string &path, const Vector4& clearColor )
+void Capture::Start(Actor source, const Vector2& position, const Vector2& size, const std::string& path, const Vector4& clearColor)
{
- GetImpl( *this ).Start( source, position, size, path, clearColor );
+ GetImpl(*this).Start(source, position, size, path, clearColor);
}
-void Capture::Start( Actor source, const Vector2& size, const std::string &path, const Vector4& clearColor, const uint32_t quality )
+void Capture::Start(Actor source, const Vector2& size, const std::string& path, const Vector4& clearColor, const uint32_t quality)
{
- GetImpl( *this ).Start( source, Vector2::ZERO, size, path, clearColor, quality );
+ GetImpl(*this).Start(source, Vector2::ZERO, size, path, clearColor, quality);
}
-void Capture::Start( Actor source, const Vector2& size, const std::string &path, const Vector4& clearColor )
+void Capture::Start(Actor source, const Vector2& size, const std::string& path, const Vector4& clearColor)
{
- GetImpl( *this ).Start( source, Vector2::ZERO, size, path, clearColor );
+ GetImpl(*this).Start(source, Vector2::ZERO, size, path, clearColor);
}
-void Capture::Start( Actor source, const Vector2& size, const std::string &path )
+void Capture::Start(Actor source, const Vector2& size, const std::string& path)
{
- GetImpl( *this ).Start( source, Vector2::ZERO, size, path, Dali::Color::TRANSPARENT );
+ GetImpl(*this).Start(source, Vector2::ZERO, size, path, Dali::Color::TRANSPARENT);
}
-void Capture::SetImageQuality( uint32_t quality )
+void Capture::SetImageQuality(uint32_t quality)
{
- return GetImpl( *this ).SetImageQuality( quality );
+ return GetImpl(*this).SetImageQuality(quality);
}
Dali::NativeImageSourcePtr Capture::GetNativeImageSource() const
{
- return GetImpl( *this ).GetNativeImageSource();
+ return GetImpl(*this).GetNativeImageSource();
}
Capture::CaptureFinishedSignalType& Capture::FinishedSignal()
{
- return GetImpl( *this ).FinishedSignal();
+ return GetImpl(*this).FinishedSignal();
}
-Capture::Capture( Internal::Adaptor::Capture* internal )
-: BaseHandle( internal )
+Capture::Capture(Internal::Adaptor::Capture* internal)
+: BaseHandle(internal)
{
}
// EXTERNAL HEADERS
#include <dali/public-api/actors/actor.h>
-#include <dali/public-api/signals/dali-signal.h>
#include <dali/public-api/actors/camera-actor.h>
+#include <dali/public-api/signals/dali-signal.h>
// INTERNAL INCLUDES
-#include <dali/public-api/dali-adaptor-common.h>
#include <dali/public-api/adaptor-framework/native-image-source.h>
+#include <dali/public-api/dali-adaptor-common.h>
namespace Dali
{
-
/**
* @addtogroup dali_adaptor_framework
* @{
{
class Capture;
}
-}
+} // namespace DALI_INTERNAL
/**
* @brief Capture snapshots the current scene and save as a file.
*/
class DALI_ADAPTOR_API Capture : public BaseHandle
{
-
public:
-
/**
* @brief The enumerations used for checking capture success
* @SINCE_1_3_4
*
* @SINCE_1_3_4
*/
- typedef Signal< void ( Capture, Capture::FinishState ) > CaptureFinishedSignalType;
+ typedef Signal<void(Capture, Capture::FinishState)> CaptureFinishedSignalType;
/**
* @brief Create an uninitialized Capture; this can be initialized with Actor::New().
* @param[in] cameraActor An initialized CameraActor.
* @return A handle to a newly allocated Dali resource.
*/
- static Capture New( Dali::CameraActor cameraActor );
+ static Capture New(Dali::CameraActor cameraActor);
/**
* @brief Downcast an Object handle to Capture handle.
* @param[in] handle to An object.
* @return handle to a Capture object or an uninitialized handle.
*/
- static Capture DownCast( BaseHandle handle );
+ static Capture DownCast(BaseHandle handle);
/**
* @brief Dali::Actor is intended as a base class.
*
* @param[in] copy A reference to the copied handle.
*/
- Capture( const Capture& copy );
+ Capture(const Capture& copy);
/**
* @brief This assignment operator is required for (smart) pointer semantics.
* @param[in] rhs A reference to the copied handle.
* @return A reference to this.
*/
- Capture& operator=( const Capture& rhs );
+ Capture& operator=(const Capture& rhs);
/**
* @brief Move constructor.
* @SINCE_1_9.24
* @param[in] rhs A reference to the moved handle
*/
- Capture( Capture&& rhs );
+ Capture(Capture&& rhs);
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this handle
*/
- Capture& operator=( Capture&& rhs );
+ Capture& operator=(Capture&& rhs);
/**
* @brief Start capture and save the image as a file.
* in this case, if source is root of scene, the captured image includes a part of actor 'B' on the 'A'.
* however, if source is just actor 'A', the result includes only 'A'.
*/
- void Start( Actor source, const Vector2& position, const Vector2& size, const std::string &path, const Vector4& clearColor );
+ void Start(Actor source, const Vector2& position, const Vector2& size, const std::string& path, const Vector4& clearColor);
/**
* @brief Start capture and save the image as a file.
* @param[in] clearColor background color of captured scene
* @param[in] quality The value to control image quality for jpeg file format in the range [1, 100]
*/
- void Start( Actor source, const Vector2& size, const std::string &path, const Vector4& clearColor, const uint32_t quality );
+ void Start(Actor source, const Vector2& size, const std::string& path, const Vector4& clearColor, const uint32_t quality);
/**
* @brief Start capture and save the image as a file.
* If path is empty string, the captured result is not be saved as a file.
* @param[in] clearColor background color of captured scene
*/
- void Start( Actor source, const Vector2& size, const std::string &path, const Vector4& clearColor );
+ void Start(Actor source, const Vector2& size, const std::string& path, const Vector4& clearColor);
/**
* @brief Start capture and save the image as a file.
* If path is empty string, the captured result is not be saved as a file.
* @note Clear color is transparent.
*/
- void Start( Actor source, const Vector2& size, const std::string &path );
+ void Start(Actor source, const Vector2& size, const std::string& path);
/**
* @brief Set result image quality in case of jpeg
*
* @param[in] quality The value to control image quality for jpeg file format in the range [1, 100]
*/
- void SetImageQuality( uint32_t quality );
+ void SetImageQuality(uint32_t quality);
/**
* @brief Get NativeImageSourcePtr that is saved captured image.
*
* @param[in] internal A pointer to a newly allocated Dali resource.
*/
- explicit DALI_INTERNAL Capture( Internal::Adaptor::Capture* internal );
+ explicit DALI_INTERNAL Capture(Internal::Adaptor::Capture* internal);
/// @endcond
};
#define DALI_ADAPTOR_COMMON_H
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
* When building a library that uses DALI, HIDE_DALI_INTERNALS.
*/
#if __GNUC__ >= 4
-# ifndef HIDE_DALI_INTERNALS
-# define DALI_ADAPTOR_API
-# else
-# define DALI_ADAPTOR_API __attribute__ ((visibility ("default")))
-# endif
+#ifndef HIDE_DALI_INTERNALS
+#define DALI_ADAPTOR_API
+#else
+#define DALI_ADAPTOR_API __attribute__((visibility("default")))
+#endif
#else
#ifdef WIN32
#ifdef BUILDING_DALI_ADAPTOR
/** Visibility attribute to hide declarations */
-# define DALI_ADAPTOR_API __declspec(dllexport)
+#define DALI_ADAPTOR_API __declspec(dllexport)
#else
/** Visibility attribute to hide declarations */
-# define DALI_ADAPTOR_API __declspec(dllimport)
+#define DALI_ADAPTOR_API __declspec(dllimport)
#endif
#else
/** Visibility attribute to show declarations */
-# define DALI_ADAPTOR_API
+#define DALI_ADAPTOR_API
#endif
#endif
namespace Dali
{
-
const unsigned int ADAPTOR_MAJOR_VERSION = 1;
const unsigned int ADAPTOR_MINOR_VERSION = 9;
const unsigned int ADAPTOR_MICRO_VERSION = 28;
-const char * const ADAPTOR_BUILD_DATE = __DATE__ " " __TIME__;
+const char* const ADAPTOR_BUILD_DATE = __DATE__ " " __TIME__;
#ifdef DEBUG_ENABLED
namespace
#define DALI_ADAPTOR_VERSION_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
DALI_ADAPTOR_API extern const unsigned int ADAPTOR_MAJOR_VERSION; ///< The major version number of the Adaptor.
DALI_ADAPTOR_API extern const unsigned int ADAPTOR_MINOR_VERSION; ///< The minor version number of the Adaptor.
DALI_ADAPTOR_API extern const unsigned int ADAPTOR_MICRO_VERSION; ///< The micro version number of the Adaptor.
-DALI_ADAPTOR_API extern const char * const ADAPTOR_BUILD_DATE; ///< The date/time the Adaptor library was built.
+DALI_ADAPTOR_API extern const char* const ADAPTOR_BUILD_DATE; ///< The date/time the Adaptor library was built.
} // namespace Dali
#endif // DALI_ADAPTOR_VERSION_H
#define DALI_WEARABLE_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
// INTERNAL INCLUDES
-#include <dali/public-api/watch/watch-application.h>
#include <dali/public-api/capture/capture.h>
+#include <dali/public-api/watch/watch-application.h>
#endif // DALI_WEARABLE_H
*/
// EXTERNAL INCLUDES
-#include <string>
#include <dali/public-api/object/base-handle.h>
#include <dali/public-api/signals/callback.h>
+#include <string>
// INTERNAL INCLUDES
-#include <dali/public-api/dali-adaptor-common.h>
#include <dali/public-api/adaptor-framework/application.h>
+#include <dali/public-api/dali-adaptor-common.h>
#include <dali/public-api/watch/watch-time.h>
namespace Dali
{
class WatchApplication;
}
-}
+} // namespace DALI_INTERNAL
/**
* @brief A WatchApplication class object should be created by every watch application
class DALI_ADAPTOR_API WatchApplication : public Application
{
public:
- typedef Signal< void (Application&, const WatchTime&) > WatchTimeSignal; ///< Watch pointer signal callback type @SINCE_1_1.37
- typedef Signal< void (Application&, bool) > WatchBoolSignal; ///< Watch bool signal callback type @SINCE_1_1.37
+ typedef Signal<void(Application&, const WatchTime&)> WatchTimeSignal; ///< Watch pointer signal callback type @SINCE_1_1.37
+ typedef Signal<void(Application&, bool)> WatchBoolSignal; ///< Watch bool signal callback type @SINCE_1_1.37
public:
-
/**
* @brief This is the constructor for applications without an argument list.
* @SINCE_1_1.37
* @param[in,out] argv A pointer the the argument list
* @return A handle to the WatchApplication
*/
- static WatchApplication New( int* argc, char **argv[] );
+ static WatchApplication New(int* argc, char** argv[]);
/**
* @brief This is the constructor for applications with a name
* @param[in] stylesheet The path to user defined theme file
* @return A handle to the WatchApplication
*/
- static WatchApplication New( int* argc, char **argv[], const std::string& stylesheet );
+ static WatchApplication New(int* argc, char** argv[], const std::string& stylesheet);
/**
* @brief Construct an empty handle
* @SINCE_1_1.37
* @param[in] implementation The WatchApplication implementation
*/
- WatchApplication( const WatchApplication& implementation );
+ WatchApplication(const WatchApplication& implementation);
/**
* @brief Assignment operator
* @param[in] application Handle to an object
* @return A reference to this
*/
- WatchApplication& operator=( const WatchApplication& application );
+ WatchApplication& operator=(const WatchApplication& application);
/**
* @brief Move constructor.
* @SINCE_1_9.24
* @param[in] rhs A reference to the moved handle
*/
- WatchApplication( WatchApplication&& rhs );
+ WatchApplication(WatchApplication&& rhs);
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this handle
*/
- WatchApplication& operator=( WatchApplication&& rhs );
+ WatchApplication& operator=(WatchApplication&& rhs);
/**
* @brief Destructor
#define DALI_WATCH_TIME_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
// EXTERNAL INCLUDES
-#include <time.h>
#include <dali/public-api/dali-core.h>
+#include <time.h>
// INTERNAL INCLUDES
#include <dali/public-api/dali-adaptor-common.h>
class DALI_ADAPTOR_API WatchTime
{
public:
-
/**
* @brief Constructor.
* @SINCE_1_1.37
bool GetDaylightSavingTimeStatus() const;
public: // Not intended for application developers
- DALI_INTERNAL WatchTime(void *time_handle);
-
-private: // Internal Data
+ DALI_INTERNAL WatchTime(void* time_handle);
+private: // Internal Data
struct Impl;
Impl* mImpl;
};
projects / platform / core / uifw / dali-adaptor.git / commitdiff