2 * Copyright (c) 2015 Samsung Electronics Co., Ltd.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
19 #include <dali-toolkit/internal/text/markup-processor-helper-functions.h>
22 #include <dali/public-api/common/constants.h>
23 #include <dali/public-api/math/vector2.h>
39 const char WHITE_SPACE = 0x20; // ASCII value of the white space.
40 const char FIRST_UPPER_CASE = 0x41; // ASCII value of the one after the first upper case character (A).
41 const char LAST_UPPER_CASE = 0x5b; // ASCII value of the one after the last upper case character (Z).
42 const char TO_LOWER_CASE = 32; // Value to add to a upper case character to transform it into a lower case.
44 const char WEB_COLOR_TOKEN( '#' );
45 const char* const HEX_COLOR_TOKEN( "0x" );
46 const char* const ALPHA_ONE( "FF" );
48 const std::string BLACK_COLOR( "black" );
49 const std::string WHITE_COLOR( "white" );
50 const std::string RED_COLOR( "red" );
51 const std::string GREEN_COLOR( "green" );
52 const std::string BLUE_COLOR( "blue" );
53 const std::string YELLOW_COLOR( "yellow" );
54 const std::string MAGENTA_COLOR( "magenta" );
55 const std::string CYAN_COLOR( "cyan" );
56 const std::string TRANSPARENT_COLOR( "transparent" );
59 bool TokenComparison( const std::string& string1, const char* const stringBuffer2, Length length )
61 const Length stringSize = string1.size();
62 if( stringSize != length )
64 // Early return. Strings have different sizes.
68 const char* const stringBuffer1 = string1.c_str();
70 for( std::size_t index = 0; index < stringSize; ++index )
72 const char character = *( stringBuffer2 + index );
73 const bool toLower = ( character < LAST_UPPER_CASE ) && ( character >= FIRST_UPPER_CASE );
74 if( *( stringBuffer1 + index ) != ( toLower ? character + TO_LOWER_CASE : character ) )
83 void SkipWhiteSpace( const char*& stringBuffer,
84 const char* const stringEndBuffer )
86 for( ; ( WHITE_SPACE >= *stringBuffer ) && ( stringBuffer < stringEndBuffer ); ++stringBuffer );
89 void JumpToWhiteSpace( const char*& stringBuffer,
90 const char* const stringEndBuffer )
92 for( ; ( WHITE_SPACE != *stringBuffer ) && ( stringBuffer < stringEndBuffer ); ++stringBuffer );
95 unsigned int StringToUint( const char* const uintStr )
97 return static_cast<unsigned int>( strtoul( uintStr, NULL, 10 ) );
100 unsigned int StringToHex( const char* const uintStr )
102 return static_cast<unsigned int>( strtoul( uintStr, NULL, 16 ) );
105 float StringToFloat( const char* const floatStr )
107 return static_cast<float>( strtod( floatStr, NULL ) );
110 void FloatToString( float value, std::string& floatStr )
112 std::stringstream ss;
117 void UintToString( unsigned int value, std::string& uIntStr )
119 std::stringstream ss;
124 void UintColorToVector4( unsigned int color, Vector4& retColor )
126 retColor.a = static_cast<float>( ( color & 0xFF000000 ) >> 24u ) / 255.f;
127 retColor.r = static_cast<float>( ( color & 0x00FF0000 ) >> 16u ) / 255.f;
128 retColor.g = static_cast<float>( ( color & 0x0000FF00 ) >> 8u ) / 255.f;
129 retColor.b = static_cast<float>( color & 0x000000FF ) / 255.f;
132 void ColorStringToVector4( const char* const colorStr, Length length, Vector4& retColor )
134 if( WEB_COLOR_TOKEN == *colorStr )
136 std::string webColor( colorStr + 1u, length - 1u );
137 if( 4u == length ) // 3 component web color #F00 (red)
139 webColor.insert( 2u, &( webColor[2] ), 1u );
140 webColor.insert( 1u, &( webColor[1] ), 1u );
141 webColor.insert( 0u, &( webColor[0] ), 1u );
142 webColor.insert( 0u, ALPHA_ONE );
144 else if( 7u == length ) // 6 component web color #FF0000 (red)
146 webColor.insert( 0u, ALPHA_ONE );
149 UintColorToVector4( StringToHex( webColor.c_str() ), retColor );
151 else if( TokenComparison( HEX_COLOR_TOKEN, colorStr, 2u ) )
153 UintColorToVector4( StringToHex( colorStr + 2u ), retColor );
155 else if( TokenComparison( BLACK_COLOR, colorStr, length ) )
157 retColor = Color::BLACK;
159 else if( TokenComparison( WHITE_COLOR, colorStr, length ) )
161 retColor = Color::WHITE;
163 else if( TokenComparison( RED_COLOR, colorStr, length ) )
165 retColor = Color::RED;
167 else if( TokenComparison( GREEN_COLOR, colorStr, length ) )
169 retColor = Color::GREEN;
171 else if( TokenComparison( BLUE_COLOR, colorStr, length ) )
173 retColor = Color::BLUE;
175 else if( TokenComparison( YELLOW_COLOR, colorStr, length ) )
177 retColor = Color::YELLOW;
179 else if( TokenComparison( MAGENTA_COLOR, colorStr, length ) )
181 retColor = Color::MAGENTA;
183 else if( TokenComparison( CYAN_COLOR, colorStr, length ) )
185 retColor = Color::CYAN;
187 else if( TokenComparison( TRANSPARENT_COLOR, colorStr, length ) )
189 retColor = Color::TRANSPARENT;
193 void Vector4ToColorString( const Vector4& value, std::string& vector2Str )
195 if( Color::BLACK == value )
197 vector2Str = BLACK_COLOR;
201 if( Color::WHITE == value )
203 vector2Str = WHITE_COLOR;
207 if( Color::RED == value )
209 vector2Str = RED_COLOR;
213 if( Color::GREEN == value )
215 vector2Str = GREEN_COLOR;
219 if( Color::BLUE == value )
221 vector2Str = BLUE_COLOR;
225 if( Color::YELLOW == value )
227 vector2Str = YELLOW_COLOR;
231 if( Color::MAGENTA == value )
233 vector2Str = MAGENTA_COLOR;
237 if( Color::CYAN == value )
239 vector2Str = CYAN_COLOR;
243 if( Color::TRANSPARENT == value )
245 vector2Str = TRANSPARENT_COLOR;
249 const unsigned int alpha = static_cast<unsigned int>( 255.f * value.a );
250 const unsigned int red = static_cast<unsigned int>( 255.f * value.r );
251 const unsigned int green = static_cast<unsigned int>( 255.f * value.g );
252 const unsigned int blue = static_cast<unsigned int>( 255.f * value.b );
254 std::stringstream ss;
255 const unsigned int size = 2u * sizeof( unsigned char );
258 << std::setfill('0') << std::setw( size )
260 << std::setfill('0') << std::setw( size )
262 << std::setfill('0') << std::setw( size )
264 << std::setfill('0') << std::setw( size )
266 vector2Str = ss.str();
269 void StringToVector2( const char* const vectorStr, Length length, Vector2& vector2 )
271 // Points to the first character of the string.
272 const char* strBuffer = vectorStr;
274 // Points to the first character of the 'x' value.
275 const char* const xBuffer = strBuffer;
277 // Jumps to the next white space.
278 JumpToWhiteSpace( strBuffer, strBuffer + length );
280 // Points to the first character of the 'y' value.
281 const char* const yBuffer = strBuffer;
283 // Converts the shadow's offset to float.
284 vector2.x = StringToFloat( xBuffer );
285 vector2.y = StringToFloat( yBuffer );
288 void Vector2ToString( const Vector2& value, std::string& vector2Str )
290 FloatToString( value.x, vector2Str );
294 FloatToString( value.y, yStr );
301 } // namespace Toolkit