../dali-toolkit/dali-toolkit-test-utils/toolkit-orientation.cpp
../dali-toolkit/dali-toolkit-test-utils/toolkit-physical-keyboard.cpp
../dali-toolkit/dali-toolkit-test-utils/toolkit-style-monitor.cpp
- ../dali-toolkit/dali-toolkit-test-utils/toolkit-singleton-service.cpp
../dali-toolkit/dali-toolkit-test-utils/toolkit-test-application.cpp
../dali-toolkit/dali-toolkit-test-utils/toolkit-timer.cpp
../dali-toolkit/dali-toolkit-test-utils/toolkit-tts-player.cpp
const static uint8_t U2 = 2u;
const static uint8_t U3 = 3u;
const static uint8_t U4 = 4u;
+ const static uint8_t U5 = 5u;
+ const static uint8_t U6 = 6u;
const static uint8_t U0 = 0u;
const static uint8_t UTF8_LENGTH[256] = {
U1, U1, U1, U1, U1, U1, U1, U1, U1, U1, //
U4, U4, U4, U4, U4, U4, U4, U4, // lead byte = 1111 0xxx (U+10000 - U+1FFFFF)
- U0, U0, U0, U0, // Non valid.
- U0, U0, U0, U0, // Non valid.
+ U5, U5, U5, U5, // lead byte = 1111 10xx (U+200000 - U+3FFFFFF)
+
+ U6, U6, // lead byte = 1111 110x (U+4000000 - U+7FFFFFFF)
+
+ U0, U0, // Non valid.
};
for( unsigned int index = 0; index < 256u; ++index )
"\xF0\x9F\x98\x81 \xF0\x9F\x98\x82 \xF0\x9F\x98\x83 \xF0\x9F\x98\x84",
7u,
},
+ {
+ "5 bytes test",
+ "\xF8\xA0\x80\x80\x80",
+ 1u,
+ },
+ {
+ "6 bytes test",
+ "\xFC\x84\x80\x80\x80\x80",
+ 1u,
+ },
};
- const unsigned int numberOfTests = 4u;
+ const unsigned int numberOfTests = 6u;
for( unsigned int index = 0u; index < numberOfTests; ++index )
{
unsigned int utf32_02[] = { 0x645, 0x631, 0x62D, 0x628, 0x627, 0x20, 0x628, 0x627, 0x644, 0x639, 0x627, 0x644, 0x645 }; // مرحبا بالعالم
unsigned int utf32_03[] = { 0x939, 0x948, 0x932, 0x94B, 0x20, 0x935, 0x930, 0x94D, 0x932, 0x94D, 0x921 }; // हैलो वर्ल्ड
unsigned int utf32_04[] = { 0x1F601, 0x20, 0x1F602, 0x20, 0x1F603, 0x20, 0x1F604 }; // Emojis
+ unsigned int utf32_05[] = { 0x800000 };
+ unsigned int utf32_06[] = { 0x4000000 };
const GetNumberOfUtf8BytesData data[] =
{
7u,
19u,
},
+ {
+ "5 bytes test",
+ utf32_05,
+ 1u,
+ 5u,
+ },
+ {
+ "6 bytes test",
+ utf32_06,
+ 1u,
+ 6u
+ },
};
- const unsigned int numberOfTests = 4u;
+ const unsigned int numberOfTests = 6u;
for( unsigned int index = 0u; index < numberOfTests; ++index )
{
ToolkitTestApplication application;
tet_infoline(" UtcDaliTextCharacterSetConversionGetNumberOfUtf8Bytes");
- char utf8_06[] = { -8, -7, -6, -5, -4, -3, -2, -1 }; // Invalid string
+ char utf8_06[] = { -2, -1 }; // Invalid string
unsigned int utf32_01[] = { 0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x20, 0x57, 0x6F, 0x72, 0x6C, 0x64 }; // Hello World
unsigned int utf32_02[] = { 0xA, 0x20, 0x48, 0x65, 0x6C, 0x6C, 0x6F, 0xA, 0x20, 0x57, 0x6F, 0x72, 0x6C, 0x64 }; // Hello World + CR and CR+LF
unsigned int utf32_03[] = { 0x645, 0x631, 0x62D, 0x628, 0x627, 0x20, 0x628, 0x627, 0x644, 0x639, 0x627, 0x644, 0x645 }; // مرحبا بالعالم
unsigned int utf32_04[] = { 0x939, 0x948, 0x932, 0x94B, 0x20, 0x935, 0x930, 0x94D, 0x932, 0x94D, 0x921 }; // हैलो वर्ल्ड
unsigned int utf32_05[] = { 0x1F601, 0x20, 0x1F602, 0x20, 0x1F603, 0x20, 0x1F604 }; // Emojis
- unsigned int utf32_06[] = { 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20 }; // Invalid string
+ unsigned int utf32_06[] = { 0x800000 };
+ unsigned int utf32_07[] = { 0x4000000 };
+ unsigned int utf32_08[] = { 0x20, 0x20 }; // Invalid string
const Utf8ToUtf32Data data[] =
{
utf32_05,
},
{
+ "5 bytes test",
+ "\xF8\xA0\x80\x80\x80",
+ utf32_06,
+ },
+ {
+ "6 bytes test",
+ "\xFC\x84\x80\x80\x80\x80",
+ utf32_07,
+ },
+ {
"Invalid text",
utf8_06,
- utf32_06,
+ utf32_08,
},
};
- const unsigned int numberOfTests = 6u;
+ const unsigned int numberOfTests = 8u;
for( unsigned int index = 0u; index < numberOfTests; ++index )
{
unsigned int utf32_02[] = { 0x645, 0x631, 0x62D, 0x628, 0x627, 0x20, 0x628, 0x627, 0x644, 0x639, 0x627, 0x644, 0x645 }; // مرحبا بالعالم
unsigned int utf32_03[] = { 0x939, 0x948, 0x932, 0x94B, 0x20, 0x935, 0x930, 0x94D, 0x932, 0x94D, 0x921 }; // हैलो वर्ल्ड
unsigned int utf32_04[] = { 0x1F601, 0x20, 0x1F602, 0x20, 0x1F603, 0x20, 0x1F604 }; // Emojis
+ unsigned int utf32_05[] = { 0x800000 };
+ unsigned int utf32_06[] = { 0x4000000 };
struct Utf32ToUtf8Data data[] =
{
7u,
"\xF0\x9F\x98\x81 \xF0\x9F\x98\x82 \xF0\x9F\x98\x83 \xF0\x9F\x98\x84",
},
+ {
+ "5 bytes test",
+ utf32_05,
+ 1u,
+ "\xF8\xA0\x80\x80\x80",
+ },
+ {
+ "6 bytes test",
+ utf32_06,
+ 1u,
+ "\xFC\x84\x80\x80\x80\x80",
+ },
};
- const unsigned int numberOfTests = 4u;
+ const unsigned int numberOfTests = 6u;
for( unsigned int index = 0u; index < numberOfTests; ++index )
{
../dali-toolkit/dali-toolkit-test-utils/toolkit-orientation.cpp
../dali-toolkit/dali-toolkit-test-utils/toolkit-physical-keyboard.cpp
../dali-toolkit/dali-toolkit-test-utils/toolkit-style-monitor.cpp
- ../dali-toolkit/dali-toolkit-test-utils/toolkit-singleton-service.cpp
../dali-toolkit/dali-toolkit-test-utils/toolkit-sound-player.cpp
../dali-toolkit/dali-toolkit-test-utils/toolkit-test-application.cpp
../dali-toolkit/dali-toolkit-test-utils/toolkit-text-abstraction.cpp
dali-toolkit-test-utils/toolkit-orientation.cpp
dali-toolkit-test-utils/toolkit-physical-keyboard.cpp
dali-toolkit-test-utils/toolkit-style-monitor.cpp
- dali-toolkit-test-utils/toolkit-singleton-service.cpp
dali-toolkit-test-utils/toolkit-test-application.cpp
dali-toolkit-test-utils/toolkit-timer.cpp
dali-toolkit-test-utils/toolkit-trigger-event-factory.cpp
*/
#include <dali/devel-api/adaptor-framework/feedback-player.h>
-#include <dali/devel-api/adaptor-framework/singleton-service.h>
+#include <dali/devel-api/common/singleton-service.h>
#include <dali/public-api/object/base-object.h>
using namespace Dali;
void ApplyOptions( const InputMethodOptions& options );
bool FilterEventKey( const Dali::KeyEvent& keyEvent );
void SetPreeditStyle( Dali::InputMethodContext::PreeditStyle type );
- void GetPreeditStyle( Vector< Dali::InputMethodContext::PreeditAttributeData >& attrs ) const;
+ void GetPreeditStyle( Dali::InputMethodContext::PreEditAttributeDataContainer& attrs ) const;
public: // Signals
ActivatedSignalType& ActivatedSignal() { return mActivatedSignal; }
bool mRestoreAfterFocusLost:1; ///< Whether the keyboard needs to be restored (activated ) after focus regained.
bool mIdleCallbackConnected:1; ///< Whether the idle callback is already connected.
InputMethodOptions mOptions;
- Vector< Dali::InputMethodContext::PreeditAttributeData > mPreeditAttrs; ///< Stores preedit attr data
+ Dali::InputMethodContext::PreEditAttributeDataContainer mPreeditAttrs; ///< Stores preedit attribute data
ActivatedSignalType mActivatedSignal;
KeyboardEventSignalType mEventSignal;
mPreeditAttrs.PushBack( data );
}
-void InputMethodContext::GetPreeditStyle( Vector< Dali::InputMethodContext::PreeditAttributeData >& attrs ) const
+void InputMethodContext::GetPreeditStyle( Dali::InputMethodContext::PreEditAttributeDataContainer& attrs ) const
{
attrs = mPreeditAttrs;
}
Internal::Adaptor::InputMethodContext::GetImplementation(*this).SetPreeditStyle( type );
}
-void InputMethodContext::GetPreeditStyle( Vector< Dali::InputMethodContext::PreeditAttributeData >& attrs ) const
+void InputMethodContext::GetPreeditStyle( Dali::InputMethodContext::PreEditAttributeDataContainer& attrs ) const
{
Internal::Adaptor::InputMethodContext::GetImplementation(*this).GetPreeditStyle( attrs );
}
*/
struct PreeditAttributeData
{
- PreeditStyle preeditType; /// The preedit style type
- unsigned int startIndex; /// The start index of preedit
- unsigned int endIndex; /// The end index of preedit
+ PreeditAttributeData()
+ : 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
};
/**
typedef Signal< void () > VoidSignalType;
typedef Signal< void (bool) > StatusSignalType;
+ using PreEditAttributeDataContainer = Vector< Dali::InputMethodContext::PreeditAttributeData >;
+
public:
/**
void SetPreeditStyle( PreeditStyle type );
/**
- * @brief Gets the preedit attrs data.
+ * @brief Gets the preedit attributes data.
*
- * @param[out] attrs The preedit attrs data.
+ * @param[out] attrs The preedit attributes data.
*/
- void GetPreeditStyle( Vector<PreeditAttributeData>& attrs ) const;
+ void GetPreeditStyle( Dali::InputMethodContext::PreEditAttributeDataContainer& attrs ) const;
public:
+++ /dev/null
-/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include <toolkit-singleton-service.h>
-
-#include <dali-toolkit/public-api/dali-toolkit-common.h>
-#include <dali/public-api/object/base-object.h>
-#include <dali/devel-api/common/map-wrapper.h>
-#include <dali/public-api/signals/dali-signal.h>
-#include <dali/integration-api/processor-interface.h>
-
-namespace Dali
-{
-
-
-namespace Internal
-{
-namespace Adaptor
-{
-
-namespace
-{
-Dali::IntrusivePtr<SingletonService> gSingletonService;
-} // unnamed namespace
-
-
-class SingletonService : public Dali::BaseObject
-{
-public:
-
- /**
- * Create a SingletonService.
- * This should only be called once by the Application class.
- * @return A newly created SingletonService.
- */
- static Dali::SingletonService New()
- {
- DALI_ASSERT_ALWAYS( 0 && "SingletonService New method used");
- gSingletonService = Dali::IntrusivePtr<SingletonService>( new SingletonService() );
- return Dali::SingletonService( gSingletonService.Get() );
- }
-
- /**
- * @copydoc Dali::SingletonService::Get()
- */
- static Dali::SingletonService Get()
- {
- Dali::SingletonService singletonService;
- if ( !gSingletonService )
- {
- gSingletonService = Dali::IntrusivePtr<SingletonService>( new SingletonService() );
- }
- return Dali::SingletonService( gSingletonService.Get() );
- }
-
- /**
- * @copydoc Dali::SingletonService::Register()
- */
- void Register( const std::type_info& info, BaseHandle singleton )
- {
- if( singleton )
- {
- mSingletonContainer.insert( SingletonPair( info.name(), singleton ) );
-
- Integration::Processor* processor = dynamic_cast<Integration::Processor*>( &singleton.GetBaseObject() );
- if( processor )
- {
- Integration::Core& core = mTestApplication->GetCore();
- core.RegisterProcessor( *processor );
- }
- }
- }
-
- /**
- * @copydoc Dali::SingletonService::UnregisterAll()
- */
- void UnregisterAll()
- {
- mSingletonContainer.clear();
- }
-
- /**
- * @copydoc Dali::SingletonService::GetSingleton()
- */
- BaseHandle GetSingleton( const std::type_info& info ) const
- {
- BaseHandle object;
-
- SingletonConstIter iter = mSingletonContainer.find(info.name());
- if( iter != mSingletonContainer.end() )
- {
- object = ( *iter ).second;
- }
- return object;
- }
-
- void SetApplication( Dali::TestApplication& testApplication )
- {
- mTestApplication = &testApplication;
- }
-
-private:
-
- /**
- * Private Constructor
- * @see SingletonService::New()
- */
- SingletonService()
- : mSingletonContainer()
- {
- // Can only have one instance of SingletonService
- DALI_ASSERT_ALWAYS( !gSingletonService && "Only one instance of SingletonService is allowed");
- gSingletonService = this;
- }
-
- /**
- * Virtual Destructor
- */
- virtual ~SingletonService()
- {
- gSingletonService = 0;
- }
-
- // Undefined
- SingletonService( const SingletonService& );
- SingletonService& operator=( SingletonService& );
-
-private:
- typedef std::pair<std::string, BaseHandle> SingletonPair;
- typedef std::map<std::string, BaseHandle> SingletonContainer;
- typedef SingletonContainer::const_iterator SingletonConstIter;
-
- SingletonContainer mSingletonContainer; ///< The container to look up singleton by its type name
- TestApplication* mTestApplication;
-};
-
-} // namespace Adaptor
-} // namespace Internal
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
-inline Internal::Adaptor::SingletonService& GetImplementation(Dali::SingletonService& player)
-{
- DALI_ASSERT_ALWAYS( player && "SingletonService handle is empty" );
- BaseObject& handle = player.GetBaseObject();
- return static_cast<Internal::Adaptor::SingletonService&>(handle);
-}
-
-inline const Internal::Adaptor::SingletonService& GetImplementation(const Dali::SingletonService& player)
-{
- DALI_ASSERT_ALWAYS( player && "SingletonService handle is empty" );
- const BaseObject& handle = player.GetBaseObject();
- return static_cast<const Internal::Adaptor::SingletonService&>(handle);
-}
-
-SingletonService::SingletonService()
-{
-}
-
-SingletonService SingletonService::New()
-{
- return Internal::Adaptor::SingletonService::New();
-}
-
-SingletonService SingletonService::Get()
-{
- return Internal::Adaptor::SingletonService::Get();
-}
-
-SingletonService::~SingletonService()
-{
-}
-
-void SingletonService::Register( const std::type_info& info, BaseHandle singleton )
-{
- GetImplementation( *this ).Register( info, singleton );
-}
-
-void SingletonService::UnregisterAll()
-{
- GetImplementation( *this ).UnregisterAll();
-}
-
-BaseHandle SingletonService::GetSingleton( const std::type_info& info ) const
-{
- return GetImplementation( *this ).GetSingleton( info );
-}
-
-SingletonService::SingletonService( Internal::Adaptor::SingletonService* singletonService )
-: BaseHandle( singletonService )
-{
-}
-
-} // namespace Dali
-
-
-namespace Test
-{
-
-void SetApplication( Dali::SingletonService singletonService, TestApplication& testApplication )
-{
- GetImplementation( singletonService ).SetApplication( testApplication );
-}
-
-} // Test
+++ /dev/null
-#ifndef DALI_TOOLKIT_TEST_SINGLETON_SERVICE_H
-#define DALI_TOOLKIT_TEST_SINGLETON_SERVICE_H
-
-/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <dali/devel-api/adaptor-framework/singleton-service.h>
-#include "test-application.h"
-
-namespace Test
-{
-
-void SetApplication( Dali::SingletonService singletonService, TestApplication& testApplication );
-
-} // Test
-
-#endif //DALI_TOOLKIT_TEST_SINGLETON_SERVICE_H
*/
#include <dali/public-api/object/base-object.h>
-#include <dali/devel-api/adaptor-framework/singleton-service.h>
+#include <dali/devel-api/common/singleton-service.h>
#include <dali/devel-api/adaptor-framework/sound-player.h>
using namespace Dali;
#include <dali/devel-api/text-abstraction/font-client.h>
#include <dali/integration-api/adaptor-framework/adaptor.h>
#include <toolkit-adaptor-impl.h>
-#include <toolkit-singleton-service.h>
#include <toolkit-lifecycle-controller.h>
namespace Dali
// Core needs to be initialized next before we start the adaptor
InitializeCore();
- auto singletonService = SingletonService::Get();
- Test::SetApplication( singletonService, *this );
-
// This will also emit the window created signals
AdaptorImpl::GetImpl( *mAdaptor ).Start( *mMainWindow );
#include <dali/devel-api/text-abstraction/segmentation.h>
#include <dali/devel-api/text-abstraction/shaping.h>
#include <dali/public-api/object/base-object.h>
-#include <dali/devel-api/adaptor-framework/singleton-service.h>
+#include <dali/devel-api/common/singleton-service.h>
#include <cstring>
using namespace Dali;
#include "keyinput-focus-manager.h"
// EXTERNAL INCLUDES
-#include <dali/devel-api/adaptor-framework/singleton-service.h>
+#include <dali/devel-api/common/singleton-service.h>
// INTERNAL INCLUDES
#include <dali-toolkit/internal/focus-manager/keyinput-focus-manager-impl.h>
#include "visual-factory.h"
// EXTERNAL INCLUDES
-#include <dali/devel-api/adaptor-framework/singleton-service.h>
+#include <dali/devel-api/common/singleton-service.h>
#include <dali/devel-api/adaptor-framework/environment-variable.h>
// INTERNAL INCLUDES
#include <cstring> // for strcmp
#include <dali/public-api/actors/layer.h>
#include <dali/devel-api/adaptor-framework/accessibility-adaptor.h>
-#include <dali/devel-api/adaptor-framework/singleton-service.h>
+#include <dali/devel-api/common/singleton-service.h>
#include <dali/devel-api/adaptor-framework/lifecycle-controller.h>
#include <dali/public-api/animation/constraints.h>
#include <dali/public-api/common/stage.h>
#include "style-manager-impl.h"
// EXTERNAL INCLUDES
-#include <dali/devel-api/adaptor-framework/singleton-service.h>
+#include <dali/devel-api/common/singleton-service.h>
#include <dali/public-api/object/type-registry.h>
#include <dali/public-api/object/type-registry-helper.h>
#include <dali/integration-api/debug.h>
const static uint8_t U2 = 2u;
const static uint8_t U3 = 3u;
const static uint8_t U4 = 4u;
+ const static uint8_t U5 = 5u;
+ const static uint8_t U6 = 6u;
const static uint8_t U0 = 0u;
const static uint8_t UTF8_LENGTH[256] = {
U1, U1, U1, U1, U1, U1, U1, U1, U1, U1, //
U4, U4, U4, U4, U4, U4, U4, U4, // lead byte = 1111 0xxx (U+10000 - U+1FFFFF)
- U0, U0, U0, U0, // Non valid.
- U0, U0, U0, U0, // Non valid.
+ U5, U5, U5, U5, // lead byte = 1111 10xx (U+200000 - U+3FFFFFF)
+
+ U6, U6, // lead byte = 1111 110x (U+4000000 - U+7FFFFFFF)
+
+ U0, U0, // Non valid.
};
const uint8_t CR = 0xd;
{
numberOfBytes += U4;
}
+ else if( code < 0x4000000u )
+ {
+ numberOfBytes += U5;
+ }
+ else if( code < 0x80000000u )
+ {
+ numberOfBytes += U6;
+ }
}
return numberOfBytes;
break;
}
+ case U5:
+ {
+ uint32_t& code = *utf32++;
+ code = leadByte & 0x03u;
+ begin++;
+ code <<= 6u;
+ code |= *begin++ & 0x3fu;
+ code <<= 6u;
+ code |= *begin++ & 0x3fu;
+ code <<= 6u;
+ code |= *begin++ & 0x3fu;
+ code <<= 6u;
+ code |= *begin++ & 0x3fu;
+ break;
+ }
+
+ case U6:
+ {
+ uint32_t& code = *utf32++;
+ code = leadByte & 0x01u;
+ begin++;
+ code <<= 6u;
+ code |= *begin++ & 0x3fu;
+ code <<= 6u;
+ code |= *begin++ & 0x3fu;
+ code <<= 6u;
+ code |= *begin++ & 0x3fu;
+ code <<= 6u;
+ code |= *begin++ & 0x3fu;
+ code <<= 6u;
+ code |= *begin++ & 0x3fu;
+ break;
+ }
+
case U0: // Invalid case
{
begin++;
}
else if( code < 0x10000u )
{
- *utf8++ = static_cast<uint8_t>( code >> 12u ) | 0xe0u; // lead byte for 2 byte sequence
+ *utf8++ = static_cast<uint8_t>( code >> 12u ) | 0xe0u; // lead byte for 3 byte sequence
*utf8++ = static_cast<uint8_t>( ( code >> 6u ) & 0x3f ) | 0x80u; // continuation byte
*utf8++ = static_cast<uint8_t>( code & 0x3f ) | 0x80u; // continuation byte
}
else if( code < 0x200000u )
{
- *utf8++ = static_cast<uint8_t>( code >> 18u ) | 0xf0u; // lead byte for 2 byte sequence
+ *utf8++ = static_cast<uint8_t>( code >> 18u ) | 0xf0u; // lead byte for 4 byte sequence
+ *utf8++ = static_cast<uint8_t>( ( code >> 12u ) & 0x3f ) | 0x80u; // continuation byte
+ *utf8++ = static_cast<uint8_t>( ( code >> 6u ) & 0x3f ) | 0x80u; // continuation byte
+ *utf8++ = static_cast<uint8_t>( code & 0x3f ) | 0x80u; // continuation byte
+ }
+ else if( code < 0x4000000u )
+ {
+ *utf8++ = static_cast<uint8_t>( code >> 24u ) | 0xf8u; // lead byte for 5 byte sequence
+ *utf8++ = static_cast<uint8_t>( ( code >> 18u ) & 0x3f ) | 0x80u; // continuation byte
+ *utf8++ = static_cast<uint8_t>( ( code >> 12u ) & 0x3f ) | 0x80u; // continuation byte
+ *utf8++ = static_cast<uint8_t>( ( code >> 6u ) & 0x3f ) | 0x80u; // continuation byte
+ *utf8++ = static_cast<uint8_t>( code & 0x3f ) | 0x80u; // continuation byte
+ }
+ else if( code < 0x80000000u )
+ {
+ *utf8++ = static_cast<uint8_t>( code >> 30u ) | 0xfcu; // lead byte for 6 byte sequence
+ *utf8++ = static_cast<uint8_t>( ( code >> 24u ) & 0x3f ) | 0x80u; // continuation byte
+ *utf8++ = static_cast<uint8_t>( ( code >> 18u ) & 0x3f ) | 0x80u; // continuation byte
*utf8++ = static_cast<uint8_t>( ( code >> 12u ) & 0x3f ) | 0x80u; // continuation byte
*utf8++ = static_cast<uint8_t>( ( code >> 6u ) & 0x3f ) | 0x80u; // continuation byte
*utf8++ = static_cast<uint8_t>( code & 0x3f ) | 0x80u; // continuation byte
// EXTERNAL INCLUDES
#include <dali/integration-api/debug.h>
-#include <dali/devel-api/adaptor-framework/singleton-service.h>
+#include <dali/devel-api/common/singleton-service.h>
#include <dali/devel-api/text-abstraction/font-client.h>
// INTERNAL INCLUDES
#include <dali-toolkit/internal/text/rendering/atlas/atlas-glyph-manager.h>
// EXTERNAL INCLUDES
-#include <dali/devel-api/adaptor-framework/singleton-service.h>
+#include <dali/devel-api/common/singleton-service.h>
// INTERNAL INCLUDES
#include <dali-toolkit/internal/text/rendering/atlas/atlas-glyph-manager-impl.h>
// EXTERNAL INCLUDES
#include <dali/integration-api/debug.h>
-#include <dali/devel-api/adaptor-framework/singleton-service.h>
+#include <dali/devel-api/common/singleton-service.h>
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/text/rendering-backend.h>
// EXTERNAL INCLUDES
#include <dali/public-api/object/base-object.h>
-#include <dali/devel-api/adaptor-framework/singleton-service.h>
+#include <dali/devel-api/common/singleton-service.h>
namespace
{
mEventData->mPreEditFlag &&
( 0u != mModel->mVisualModel->mCharactersToGlyph.Count() ) )
{
- Vector< Dali::InputMethodContext::PreeditAttributeData > attrs;
+ Dali::InputMethodContext::PreEditAttributeDataContainer attrs;
mEventData->mInputMethodContext.GetPreeditStyle( attrs );
Dali::InputMethodContext::PreeditStyle type = Dali::InputMethodContext::PreeditStyle::NONE;
// Check the type of preedit and run it.
- for( Vector<Dali::InputMethodContext::PreeditAttributeData>::Iterator it = attrs.Begin(), endIt = attrs.End(); it != endIt; it++ )
+ for( Dali::InputMethodContext::PreEditAttributeDataContainer::Iterator it = attrs.Begin(), endIt = attrs.End(); it != endIt; it++ )
{
Dali::InputMethodContext::PreeditAttributeData attrData = *it;
DALI_LOG_INFO( gLogFilter, Debug::General, "Controller::UpdateModel PreeditStyle type : %d start %d end %d \n", attrData.preeditType, attrData.startIndex, attrData.endIndex );
- type = attrData.preeditType;
+ type = attrData.preeditType;
// Check the number of commit characters for the start position.
unsigned int numberOfCommit = mEventData->mPrimaryCursorPosition - mEventData->mPreEditLength;
// Add the underline for the pre-edit text.
GlyphRun underlineRun;
underlineRun.glyphIndex = attrData.startIndex + numberOfCommit;
- underlineRun.numberOfGlyphs = attrData.endIndex - attrData.startIndex;
+ underlineRun.numberOfGlyphs = numberOfIndices;
mModel->mVisualModel->mUnderlineRuns.PushBack( underlineRun );
break;
}
GlyphRun underlineRun;
underlineRun.glyphIndex = attrData.startIndex + numberOfCommit;
- underlineRun.numberOfGlyphs = attrData.endIndex - attrData.startIndex;
+ underlineRun.numberOfGlyphs = numberOfIndices;
mModel->mVisualModel->mUnderlineRuns.PushBack( underlineRun );
break;
}
GlyphRun underlineRun;
underlineRun.glyphIndex = attrData.startIndex + numberOfCommit;
- underlineRun.numberOfGlyphs = attrData.endIndex - attrData.startIndex;
+ underlineRun.numberOfGlyphs = numberOfIndices;
mModel->mVisualModel->mUnderlineRuns.PushBack( underlineRun );
break;
}
GlyphRun underlineRun;
underlineRun.glyphIndex = attrData.startIndex + numberOfCommit;
- underlineRun.numberOfGlyphs = attrData.endIndex - attrData.startIndex;
+ underlineRun.numberOfGlyphs = numberOfIndices;
mModel->mVisualModel->mUnderlineRuns.PushBack( underlineRun );
break;
}
GlyphRun underlineRun;
underlineRun.glyphIndex = attrData.startIndex + numberOfCommit;
- underlineRun.numberOfGlyphs = attrData.endIndex - attrData.startIndex;
+ underlineRun.numberOfGlyphs = numberOfIndices;
mModel->mVisualModel->mUnderlineRuns.PushBack( underlineRun );
break;
}
struct Data
{
Data()
- : loadCompleted( false )
+ : url(),
+ textureSet(),
+ hash( 0 ),
+ croppedWidth( 0 ),
+ croppedHeight( 0 ),
+ border( 0, 0, 0, 0 ),
+ loadCompleted( false )
{}
std::string url; ///< Url of the N-Patch
// EXTERNAL INCLUDES
#include <dali/integration-api/debug.h>
-#include <dali/devel-api/adaptor-framework/singleton-service.h>
+#include <dali/devel-api/common/singleton-service.h>
// INTERNAL INCLUDES
#include <dali-toolkit/internal/accessibility-manager/accessibility-manager-impl.h>
const unsigned int TOOLKIT_MAJOR_VERSION = 1;
const unsigned int TOOLKIT_MINOR_VERSION = 9;
-const unsigned int TOOLKIT_MICRO_VERSION = 0;
+const unsigned int TOOLKIT_MICRO_VERSION = 1;
const char * const TOOLKIT_BUILD_DATE = __DATE__ " " __TIME__;
#ifdef DEBUG_ENABLED
Name: dali-toolkit
Summary: Dali 3D engine Toolkit
-Version: 1.9.0
+Version: 1.9.1
Release: 1
Group: System/Libraries
License: Apache-2.0 and BSD-3-Clause and MIT
projects / platform / core / uifw / dali-toolkit.git / commitdiff