Ensure UserDefined Font family is not changed by system font changing.
[platform/core/uifw/dali-toolkit.git] / dali-toolkit / internal / controls / renderers / gradient / gradient.cpp
1 /*
2  * Copyright (c) 2015 Samsung Electronics Co., Ltd.
3  *
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
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
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.
15  *
16  */
17
18 #include "gradient.h"
19
20 #include <algorithm>    // std::sort
21 #include <dali/public-api/math/vector4.h>
22
23 namespace
24 {
25 // The maximum width of the lookup texture ( it is a 1-dimension texture with the height as 1 )
26 const unsigned int MAXIMUM_TEXTURE_RESOLUTION(128u);
27 }
28
29 namespace Dali
30 {
31
32 namespace Toolkit
33 {
34
35 namespace Internal
36 {
37
38 Gradient::Gradient()
39 : mGradientUnits( OBJECT_BOUNDING_BOX ),
40   mSpreadMethod( PAD )
41 {}
42
43 Gradient::~Gradient()
44 {}
45
46 void Gradient::AddStop( float offset, const Vector4& color )
47 {
48   // the offset is clamped to the range [0.0, 1.0]
49   mGradientStops.PushBack( GradientStop( Clamp( offset, 0.f, 1.f ), color) );
50 }
51
52 void Gradient::SetGradientUnits( GradientUnits gradientUnits )
53 {
54   mGradientUnits = gradientUnits;
55 }
56
57 Gradient::GradientUnits Gradient::GetGradientUnits() const
58 {
59   return mGradientUnits;
60 }
61
62 void Gradient::SetSpreadMethod( SpreadMethod spread )
63 {
64   mSpreadMethod = spread;
65 }
66
67 Gradient::SpreadMethod Gradient::GetSpreadMethod() const
68 {
69   return mSpreadMethod;
70 }
71
72 const Matrix3& Gradient::GetAlignmentTransform() const
73 {
74   return mAlignmentTransform;
75 }
76
77 /**
78  * Following the SVG gradient.
79  *
80  * Not only the spread method decides the texture wrap mode:
81  *    PAD-->GL_CLAMP_TO_EDGE; REPEAT-->GL_REPEAT; REFLECT-->GL_MIRROR_REPEAT
82  *
83  *  If the stops have not covered the whole zero to one range,
84  *  the REPEAT spread behaves different from the two others in the lookup texture generation.
85  */
86 BufferImage Gradient::GenerateLookupTexture()
87 {
88   std::sort( mGradientStops.Begin(), mGradientStops.End() );
89
90   unsigned int numStops = mGradientStops.Count();
91
92   /**
93    * If the stops have not covered the whole zero to one range,
94    * for PAD and REFLECT, use the color of the first stop to fill the range  [0.0, first stop offset)
95    *                  and use the color of the last stop to fill the range (last stop offset, 1.0]
96    * for REPEAT, mix the two color of the first and last stop to fill the remainder
97    */
98   bool tempFirstStop = false;
99   if( mGradientStops[0].mOffset > 0.f )
100   {
101     tempFirstStop = true;
102     Vector4 firstStopColor( mGradientStops[0].mStopColor ); // If spread method is PAD or REFLECT
103     if( mSpreadMethod == REPEAT )
104     {
105       firstStopColor = ( mGradientStops[0].mStopColor * (1.f-mGradientStops[numStops-1].mOffset)
106                        + mGradientStops[numStops-1].mStopColor  * mGradientStops[0].mOffset )
107                    / ( mGradientStops[0].mOffset+1.f-mGradientStops[numStops-1].mOffset);
108     }
109
110     mGradientStops.Insert( mGradientStops.Begin(), GradientStop(0.f, firstStopColor) );
111     numStops++;
112   }
113
114   bool tempLastStop = false;
115   if( mGradientStops[numStops-1].mOffset < 1.f )
116   {
117     tempLastStop = true;
118     Vector4 lastStopColor( mGradientStops[numStops-1].mStopColor ); // If spread method is PAD or REFLECT
119     if( mSpreadMethod == REPEAT )
120     {
121       lastStopColor = mGradientStops[0].mStopColor;
122     }
123     mGradientStops.PushBack( GradientStop(1.f, lastStopColor) );
124     numStops++;
125   }
126
127   /**
128    * Generate the pixels with the color transit from one stop to next.
129    */
130   unsigned int resolution = EstimateTextureResolution();
131   BufferImage texture = BufferImage::New( resolution, 1 );
132   PixelBuffer* pixels = texture.GetBuffer();
133   int segmentStart = 0;
134   int segmentEnd = 0;
135   int k = 0;
136   float length = static_cast<float>(resolution);
137   for( unsigned int i=0; i<numStops-1u; i++ )
138   {
139     segmentEnd = floorf(mGradientStops[i+1].mOffset * length + 0.5f);
140     if( segmentEnd == segmentStart )
141     {
142       continue;
143     }
144     float segmentWidth = static_cast<float>(segmentEnd-segmentStart);
145
146     for( int j = segmentStart; j<segmentEnd; j++ )
147     {
148       float ratio = static_cast<float>(j-segmentStart)/segmentWidth;
149       Vector4 currentColor = mGradientStops[i].mStopColor * (1.f-ratio) + mGradientStops[i+1].mStopColor * ratio;
150       pixels[k*4] = static_cast<unsigned char>( 255.f * Clamp( currentColor.r, 0.f, 1.f ) );
151       pixels[k*4+1] = static_cast<unsigned char>( 255.f * Clamp( currentColor.g, 0.f, 1.f ) );
152       pixels[k*4+2] = static_cast<unsigned char>( 255.f * Clamp( currentColor.b, 0.f, 1.f ) );
153       pixels[k*4+3] = static_cast<unsigned char>( 255.f * Clamp( currentColor.a, 0.f, 1.f ) );
154       k++;
155     }
156     segmentStart = segmentEnd;
157   }
158
159   // remove the stops added temporarily for generating the pixels, as the spread method might get changed later
160   if( tempLastStop )
161   {
162     mGradientStops.Erase( mGradientStops.Begin()+numStops-1 );
163   }
164   if( tempFirstStop )
165   {
166     mGradientStops.Erase( mGradientStops.Begin());
167   }
168
169   return texture;
170 }
171
172 unsigned int Gradient::EstimateTextureResolution()
173 {
174   float minInterval = 1.0;
175   for( unsigned int i=0, numStops = mGradientStops.Count(); i<numStops-1u; i++ )
176   {
177     float interval = mGradientStops[i+1].mOffset - mGradientStops[i].mOffset;
178     minInterval = interval > minInterval ? minInterval:interval;
179   }
180   // Use at least three pixels for each segment between two stops
181   unsigned int resolution = static_cast<int>(3.f/(minInterval+Math::MACHINE_EPSILON_100)+0.5f);
182   // Clamp the resolution to handle the overlapping stops
183   if( resolution > MAXIMUM_TEXTURE_RESOLUTION )
184   {
185     return MAXIMUM_TEXTURE_RESOLUTION;
186   }
187
188   return resolution;
189 }
190
191 } // namespace Internal
192
193 } // namespace Toolkit
194
195 } // namespace Dali