1 /*
2 * Copyright (c) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include "dtk_test_ext.h"
16 #include "text/font_types.h"
17 #include "text/text_blob_builder.h"
18 #include "text/font_mgr.h"
19 #include "text/font.h"
20 #include "recording/mem_allocator.h"
21 #include "text/font_style_set.h"
22 #include "text/rs_xform.h"
23 #include "utils/point.h"
24 #include "utils/rect.h"
25 #include "text/typeface.h"
26 #include "text/font_style.h"
27 #include <sstream>
28
29 namespace OHOS {
30 namespace Rosen {
31
DrawTextBlob(std::vector<std::string> & texts,std::shared_ptr<Drawing::TextBlob> textBlob,Drawing::Font & font1,TestPlaybackCanvas * playbackCanvas)32 static void DrawTextBlob(std::vector<std::string>& texts, std::shared_ptr<Drawing::TextBlob> textBlob,
33 Drawing::Font& font1, TestPlaybackCanvas* playbackCanvas)
34 {
35 int line = 200;
36 int interval1 = 100;
37 int interval2 = 200;
38 int interval3 = 300;
39 int interval4 = 400;
40
41 for (auto text : texts) {
42 std::shared_ptr<Drawing::TextBlob> textinfo = Drawing::TextBlob::MakeFromText(text.c_str(), text.size(), font1);
43 Drawing::Brush brush;
44 playbackCanvas->AttachBrush(brush);
45 playbackCanvas->DrawTextBlob(textBlob.get(), interval2, line);
46 playbackCanvas->DrawTextBlob(textinfo.get(), interval2, line + interval1);
47 playbackCanvas->DetachBrush();
48 Drawing::Pen pen;
49 playbackCanvas->AttachPen(pen);
50 playbackCanvas->DrawTextBlob(textBlob.get(), interval2, line + interval2);
51 playbackCanvas->DrawTextBlob(textBlob.get(), interval2, line + interval3);
52 playbackCanvas->DetachPen();
53 line += interval4;
54 }
55 }
56
57 // 用例 Font_Scene_Transform_0001
58 DEF_DTK(Font_Scene_Transform_1, TestLevel::L2, 1)
59 {
60 // 1.创建typeface
61 std::shared_ptr<Drawing::Typeface> typeface = Drawing::Typeface::MakeFromFile("/system/fonts/HarmonyOS_Sans.ttf");
62 // 2.组合typeface操作接口
63 auto familyNamex = typeface->GetFamilyName();
64 std::string typefacestr = "GetFamilyName = " + familyNamex;
65 // 3.组合Font类接口,如果是操作类有返回值的接口,获取接口返回值加入vector容器
66 auto font = Drawing::Font(typeface, 50.f, 1.0f, 1.0f);
67 font.SetSubpixel(false);
68 font.SetEdging(Drawing::FontEdging::ANTI_ALIAS);
69 auto font1 = Drawing::Font(typeface, 50.f, 1.0f, 1.0f);
70 font1.SetSubpixel(font.IsSubpixel());
71 font1.SetEdging(font.GetEdging());
72
73 // 4.创建TextBlob
74 Drawing::TextBlobBuilder builder;
75 auto buffer = builder.AllocRunPos(font1, 20, nullptr);
76 for (int i = 0; i < 20; i++) {
77 buffer.glyphs[i] = font1.UnicharToGlyph(0x9088);
78 buffer.pos[i * 2] = 50.f * i;
79 buffer.pos[i * 2 + 1] = 0;
80 }
81 std::shared_ptr<Drawing::TextBlob> textBlob = builder.Make();
82
83 // 5.组合textBlob类接口,如果有返回值则获取上一步创建的textBlob返回值打印
84 Drawing::Paint paint;
85 paint.SetColor(0xFFFF0000);
86 float boundsx[] = {1, 2, 3};
87 int intercepts = textBlob->GetIntercepts(boundsx, nullptr, &paint);
88 std::string text2 = "intercepts = " + std::to_string(intercepts);
89
90 //6. 得到需要绘制的所有返回值text,全部适应固定的textBlob构造方式打印
91 std::vector<std::string> texts = {typefacestr, text2};
92
93 //7.调用ClipIRect截取(0,0,1000,1000)区域（缺省,默认INTERSECT、不抗锯齿）
94 auto rect1 = Drawing::RectI(0, 0, 1000, 1000);
95 playbackCanvas_->ClipIRect(rect1, Drawing::ClipOp::INTERSECT);
96
97 //8.调用Scale,Rotate,ConcatMatrix
98 Drawing::Matrix matrix;
99 playbackCanvas_->ConcatMatrix(matrix);
100
101 //9.最终绘制
102 DrawTextBlob(texts, textBlob, font1, playbackCanvas_);
103 }
104
105 // 用例 Font_Scene_Transform_0002
106 DEF_DTK(Font_Scene_Transform_1, TestLevel::L2, 2)
107 {
108 // 1.创建typeface
109 std::shared_ptr<Drawing::Typeface> typeface = Drawing::Typeface::MakeFromFile("/system/fonts/HarmonyOS_Sans.ttf");
110 // 2.组合typeface操作接口
111 auto familyNamex = typeface->GetFamilyName();
112 std::string typefacestr = "GetFamilyName = " + familyNamex;
113 // 3.组合Font类接口,如果是操作类有返回值的接口,获取接口返回值加入vector容器
114 auto font = Drawing::Font(typeface, 50.f, 1.0f, 1.0f);
115 font.SetSubpixel(false);
116 font.SetEdging(Drawing::FontEdging::ANTI_ALIAS);
117 auto font1 = Drawing::Font(typeface, 50.f, 1.0f, 1.0f);
118 font1.SetSubpixel(font.IsSubpixel());
119 font1.SetEdging(font.GetEdging());
120
121 // 4.创建TextBlob
122 Drawing::TextBlobBuilder builder;
123 auto buffer = builder.AllocRunPos(font1, 20, nullptr);
124 for (int i = 0; i < 20; i++) {
125 buffer.glyphs[i] = font1.UnicharToGlyph(0x9088);
126 buffer.pos[i * 2] = 50.f * i;
127 buffer.pos[i * 2 + 1] = 0;
128 }
129 std::shared_ptr<Drawing::TextBlob> textBlob = builder.Make();
130
131 // 5.组合textBlob类接口,如果有返回值则获取上一步创建的textBlob返回值打印
132 std::string text = "harmony_os";
133 std::vector<uint16_t> glyphid;
134 Drawing::TextBlob::GetDrawingGlyphIDforTextBlob(textBlob.get(), glyphid);
135 std::string text2 = "";
136 for (int row = 0; row < text.size() && row < glyphid.size(); row++) {
137 text2 += std::string(1, text[row]) + "：" + std::to_string(glyphid[row]);
138 }
139
140 //6. 得到需要绘制的所有返回值text,全部适应固定的textBlob构造方式打印
141 std::vector<std::string> texts = {typefacestr, text2};
142
143 //7.调用ClipIRect截取(0,0,1000,1000)区域（缺省,默认INTERSECT、不抗锯齿）
144 auto rect1 = Drawing::RectI(0, 0, 1000, 1000);
145 playbackCanvas_->ClipIRect(rect1, Drawing::ClipOp::INTERSECT);
146
147 //8.调用Scale,Rotate,ConcatMatrix
148 Drawing::Matrix matrix;
149 playbackCanvas_->ConcatMatrix(matrix);
150 playbackCanvas_->Rotate(45, 50, 50);
151 playbackCanvas_->Scale(0.5, 0.5);
152
153 //9.最终绘制
154 DrawTextBlob(texts, textBlob, font1, playbackCanvas_);
155 }
156
157 // 用例 Font_Scene_Transform_0003
158 DEF_DTK(Font_Scene_Transform_1, TestLevel::L2, 3)
159 {
160 // 1.创建typeface
161 std::shared_ptr<Drawing::Typeface> typeface = Drawing::Typeface::MakeFromFile("/system/fonts/HarmonyOS_Sans.ttf");
162 // 2.组合typeface操作接口
163 std::string s = "011c50";
164 int a;
165 std::stringstream ss;
166 ss<<std::hex<<s;
167 ss>>a;
168 uint32_t tagid = *(reinterpret_cast<uint32_t*>(const_cast<char*>(s.c_str())));
169 std::string typefacestr = "GetTableData = "
170 + std::to_string(typeface->GetTableData(tagid, a, typeface->GetTableSize(tagid), nullptr));
171 // 3.组合Font类接口,如果是操作类有返回值的接口,获取接口返回值加入vector容器
172 auto font = Drawing::Font(typeface, 50.f, 1.0f, 1.0f);
173 font.SetSubpixel(false);
174 font.SetHinting(Drawing::FontHinting::NORMAL);
175 auto font1 = Drawing::Font(typeface, 50.f, 1.0f, 1.0f);
176 font1.SetSubpixel(font.IsSubpixel());
177 font1.SetHinting(font.GetHinting());
178
179 // 4.创建TextBlob
180 Drawing::TextBlobBuilder builder;
181 auto buffer = builder.AllocRunPos(font1, 20, nullptr);
182 for (int i = 0; i < 20; i++) {
183 buffer.glyphs[i] = font1.UnicharToGlyph(0x9088);
184 buffer.pos[i * 2] = 50.f * i;
185 buffer.pos[i * 2 + 1] = 0;
186 }
187 std::shared_ptr<Drawing::TextBlob> textBlob = builder.Make();
188
189 // 5.组合textBlob类接口,如果有返回值则获取上一步创建的textBlob返回值打印
190 std::vector<Drawing::Point> points;
191 Drawing::TextBlob::GetDrawingPointsForTextBlob(textBlob.get(), points);
192 std::string text2 = "";
193 for (int i = 0; i < points.size(); i++) {
194 text2 += std::to_string(i) + "-- X：" + std::to_string(points[i].GetX())
195 + "Y：" + std::to_string(points[i].GetY());
196 }
197
198 //6. 得到需要绘制的所有返回值text,全部适应固定的textBlob构造方式打印
199 std::vector<std::string> texts = {typefacestr, text2};
200
201 //7.调用ClipIRect截取(0,0,1000,1000)区域（缺省,默认INTERSECT、不抗锯齿）
202 auto rrect = Drawing::RoundRect(Drawing::Rect(0, 0, 1000, 1000), 52, 52);
203 playbackCanvas_->ClipRoundRect(rrect);
204
205 //8.调用Scale,Rotate,ConcatMatrix
206 playbackCanvas_->Translate(400, 600);
207
208 //9.最终绘制
209 DrawTextBlob(texts, textBlob, font1, playbackCanvas_);
210 }
211
212 // 用例 Font_Scene_Transform_0004
213 DEF_DTK(Font_Scene_Transform_1, TestLevel::L2, 4)
214 {
215 // 1.创建typeface
216 std::shared_ptr<Drawing::Typeface> typeface = Drawing::Typeface::MakeFromFile("/system/fonts/HarmonyOS_Sans.ttf");
217 // 2.组合typeface操作接口
218 std::string typefacestr = "GetUnitsPerEm = " + std::to_string(typeface->GetUnitsPerEm());
219 // 3.组合Font类接口,如果是操作类有返回值的接口,获取接口返回值加入vector容器
220 auto font1 = Drawing::Font(typeface, 50.f, 1.0f, 1.0f);
221 font1.SetSubpixel(false);
222 std::string text0 = "DDGR ddgr 鸿蒙 !@#￥%^&*; : , 。";
223 int glyphCount = font1.CountText(text0.c_str(), text0.length(), Drawing::TextEncoding::UTF8);
224 float widths[glyphCount];
225 uint16_t glyphs[glyphCount];
226 font1.TextToGlyphs(text0.c_str(), text0.length(), Drawing::TextEncoding::UTF8, glyphs, glyphCount);
227 font1.GetWidths(glyphs, glyphCount, widths);
228 std::string text4 = "Getwidths = " + std::to_string(widths[0]);
229
230 // 4.创建TextBlob
231 Drawing::TextBlobBuilder builder;
232 auto buffer = builder.AllocRunPos(font1, 20, nullptr);
233 for (int i = 0; i < 20; i++) {
234 buffer.glyphs[i] = font1.UnicharToGlyph(0x9088);
235 buffer.pos[i * 2] = 50.f * i;
236 buffer.pos[i * 2 + 1] = 0;
237 }
238 std::shared_ptr<Drawing::TextBlob> textBlob = builder.Make();
239
240 // 5.组合textBlob类接口,如果有返回值则获取上一步创建的textBlob返回值打印
241 std::string text = "harmony_os";
242 std::vector<uint16_t> glyphid;
243 Drawing::TextBlob::GetDrawingGlyphIDforTextBlob(textBlob.get(), glyphid);
244 playbackCanvas_->Translate(200, 200);
245 for (int row = 0; row < text.size() && row < glyphid.size(); row++) {
246 auto path = Drawing::TextBlob::GetDrawingPathforTextBlob(glyphid[row], textBlob.get());
247 playbackCanvas_->DrawPath(path);
248 playbackCanvas_->Translate(0, 100);
249 }
250
251 //6. 得到需要绘制的所有返回值text,全部适应固定的textBlob构造方式打印
252 std::vector<std::string> texts = {typefacestr, text4};
253
254 //7.调用ClipIRect截取(0,0,1000,1000)区域（缺省,默认INTERSECT、不抗锯齿）
255 auto rect1 = Drawing::RectI(0, 0, 1000, 1000);
256 playbackCanvas_->ClipIRect(rect1, Drawing::ClipOp::INTERSECT);
257
258 //8.调用Scale,Rotate,ConcatMatrix
259 Drawing::Matrix matrix;
260 playbackCanvas_->ConcatMatrix(matrix);
261 playbackCanvas_->Scale(0.5, 0.5);
262
263 //9.最终绘制
264 DrawTextBlob(texts, textBlob, font1, playbackCanvas_);
265 }
266
267 // 用例 Font_Scene_Transform_0006
268 DEF_DTK(Font_Scene_Transform_1, TestLevel::L2, 6)
269 {
270 // 1.创建typeface
271 std::shared_ptr<Drawing::Typeface> typeface = Drawing::Typeface::MakeFromFile("/system/fonts/HarmonyOS_Sans.ttf");
272 // 2.组合typeface操作接口
273 std::string typefacestr = "GetItalic = " + std::to_string(typeface->GetItalic());
274 // 3.组合Font类接口,如果是操作类有返回值的接口,获取接口返回值加入vector容器
275 auto font = Drawing::Font(typeface, 50.f, 1.0f, 1.0f);
276 font.SetSubpixel(false);
277 font.SetEmbeddedBitmaps(true);
278 auto font1 = Drawing::Font(typeface, 50.f, 1.0f, 1.0f);
279 font1.SetSubpixel(font.IsSubpixel());
280 font1.SetEmbeddedBitmaps(font.IsEmbeddedBitmaps());
281
282 // 4.创建TextBlob
283 Drawing::TextBlobBuilder builder;
284 auto buffer = builder.AllocRunRSXform(font1, 20);
285 for (int i = 0; i < 20; i++) {
286 buffer.glyphs[i] = font1.UnicharToGlyph(0x30);
287 buffer.pos[i * 4] = cos(i * 18);
288 buffer.pos[i * 4 + 1] = sin(18 * i);
289 buffer.pos[i * 4 + 2] = 100;
290 buffer.pos[i * 4 + 3] = 100;
291 }
292 std::shared_ptr<Drawing::TextBlob> textBlob = builder.Make();
293
294 // 5.组合textBlob类接口,如果有返回值则获取上一步创建的textBlob返回值打印
295 auto rect = textBlob->Bounds();
296 playbackCanvas_->DrawRect(*rect);
297
298 //6. 得到需要绘制的所有返回值text,全部适应固定的textBlob构造方式打印
299 std::vector<std::string> texts = {typefacestr};
300
301 //7.调用ClipIRect截取(0,0,1000,1000)区域（缺省,默认INTERSECT、不抗锯齿）
302 Drawing::Region region;
303 region.SetRect(Drawing::RectI(100, 100, 500, 500));
304 playbackCanvas_->ClipRegion(region);
305
306 //8.调用Scale,Rotate,ConcatMatrix
307 Drawing::Matrix matrix;
308 playbackCanvas_->ConcatMatrix(matrix);
309 playbackCanvas_->Rotate(45, 50, 50);
310
311 //9.最终绘制
312 DrawTextBlob(texts, textBlob, font1, playbackCanvas_);
313 }
314
315 // 用例 Font_Scene_Transform_0007
316 DEF_DTK(Font_Scene_Transform_1, TestLevel::L2, 7)
317 {
318 // 1.创建typeface
319 std::shared_ptr<Drawing::Typeface> typeface = Drawing::Typeface::MakeFromFile("/system/fonts/HarmonyOS_Sans.ttf");
320 // 2.组合typeface操作接口
321 std::string typefacestr = "IsCustomTypeface = " + std::to_string(typeface->IsCustomTypeface());
322 // 3.组合Font类接口,如果是操作类有返回值的接口,获取接口返回值加入vector容器
323 auto font1 = Drawing::Font(typeface, 50.f, 1.0f, 1.0f);
324 font1.SetSubpixel(false);
325 std::string text0 = "DDGR ddgr 鸿蒙 !@#￥%^&*; : , 。";
326 auto scalar = font1.UnicharToGlyph(0x44);
327 std::string text4 = "Glyphs = " + std::to_string(scalar);
328
329 // 4.创建TextBlob
330 Drawing::TextBlobBuilder builder;
331 auto buffer = builder.AllocRunRSXform(font1, 20);
332 for (int i = 0; i < 20; i++) {
333 buffer.glyphs[i] = font1.UnicharToGlyph(0x30);
334 buffer.pos[i * 4] = cos(i * 18);
335 buffer.pos[i * 4 + 1] = sin(18 * i);
336 buffer.pos[i * 4 + 2] = 100;
337 buffer.pos[i * 4 + 3] = 100;
338 }
339 std::shared_ptr<Drawing::TextBlob> textBlob = builder.Make();
340
341 // 5.组合textBlob类接口,如果有返回值则获取上一步创建的textBlob返回值打印
342 std::vector<Drawing::Point> points;
343 Drawing::TextBlob::GetDrawingPointsForTextBlob(textBlob.get(), points);
344 std::string text2 = "";
345 for (int i = 0; i < points.size(); i++) {
346 text2 += std::to_string(i) + "-- X：" + std::to_string(points[i].GetX())
347 + "Y：" + std::to_string(points[i].GetY());
348 }
349
350 //6. 得到需要绘制的所有返回值text,全部适应固定的textBlob构造方式打印
351 std::vector<std::string> texts = {typefacestr, text2, text4};
352
353 //7.调用ClipIRect截取(0,0,1000,1000)区域（缺省,默认INTERSECT、不抗锯齿）
354 Drawing::Path path;
355 path.AddOval({100, 100, 356, 356});
356 playbackCanvas_->ClipPath(path);
357
358 //8.调用Scale,Rotate,ConcatMatrix
359 Drawing::Matrix matrix;
360 playbackCanvas_->ConcatMatrix(matrix);
361 playbackCanvas_->Rotate(45, 50, 50);
362 playbackCanvas_->Translate(400, 600);
363
364 //9.最终绘制
365 DrawTextBlob(texts, textBlob, font1, playbackCanvas_);
366 }
367
368 // 用例 Font_Scene_Transform_0008
369 DEF_DTK(Font_Scene_Transform_1, TestLevel::L2, 8)
370 {
371 // 1.创建typeface
372 std::shared_ptr<Drawing::Typeface> typeface = Drawing::Typeface::MakeFromFile("/system/fonts/HarmonyOS_Sans.ttf");
373 // 2.组合typeface操作接口
374 std::string str = "CPAL";
375 reverse(str.begin(), str.end());
376 uint32_t tagid = *(reinterpret_cast<uint32_t*>(const_cast<char*>(str.c_str())));
377 std::string typefacestr = "GetTableSize = " + std::to_string(typeface->GetTableSize(tagid));
378 // 3.组合Font类接口,如果是操作类有返回值的接口,获取接口返回值加入vector容器
379 auto font = Drawing::Font(typeface, 50.f, 1.0f, 1.0f);
380 font.SetSubpixel(false);
381 font.SetForceAutoHinting(false);
382 auto font1 = Drawing::Font(typeface, 50.f, 1.0f, 1.0f);
383 font1.SetSubpixel(font.IsSubpixel());
384 font1.SetForceAutoHinting(font.IsForceAutoHinting());
385
386 // 4.创建TextBlob
387 std::string textInfo = "����������������������";
388 std::shared_ptr<Drawing::TextBlob> textBlob = Drawing::TextBlob::MakeFromText(
389 textInfo.c_str(), textInfo.size(), font1, Drawing::TextEncoding::UTF8);
390
391 // 5.组合textBlob类接口,如果有返回值则获取上一步创建的textBlob返回值打印
392 std::string text = "harmony_os";
393 std::vector<uint16_t> glyphid;
394 Drawing::TextBlob::GetDrawingGlyphIDforTextBlob(textBlob.get(), glyphid);
395 playbackCanvas_->Translate(200, 200);
396 for (int row = 0; row < text.size() && row < glyphid.size(); row++) {
397 auto path = Drawing::TextBlob::GetDrawingPathforTextBlob(glyphid[row], textBlob.get());
398 playbackCanvas_->DrawPath(path);
399 playbackCanvas_->Translate(0, 100);
400 }
401
402 //6. 得到需要绘制的所有返回值text,全部适应固定的textBlob构造方式打印
403 std::vector<std::string> texts = {typefacestr};
404
405 //7.调用ClipIRect截取(0,0,1000,1000)区域（缺省,默认INTERSECT、不抗锯齿）
406 Drawing::Path path;
407 path.AddOval({100, 100, 356, 356});
408 playbackCanvas_->ClipPath(path);
409
410 //8.调用Scale,Rotate,ConcatMatrix
411 playbackCanvas_->Scale(0.5, 0.5);
412
413 //9.最终绘制
414 DrawTextBlob(texts, textBlob, font1, playbackCanvas_);
415 }
416
417 // 用例 Font_Scene_Transform_0009
418 DEF_DTK(Font_Scene_Transform_1, TestLevel::L2, 9)
419 {
420 // 1.创建typeface
421 std::shared_ptr<Drawing::Typeface> typeface = Drawing::Typeface::MakeFromFile("/system/fonts/HarmonyOS_Sans.ttf");
422 // 2.组合typeface操作接口
423 auto data = typeface->Serialize();
424 uint32_t size = 10;
425 typeface->SetSize(size);
426 std::shared_ptr<Drawing::Typeface> typeface1 = Drawing::Typeface::Deserialize(data->GetData(), typeface->GetSize());
427 // 3.组合Font类接口,如果是操作类有返回值的接口,获取接口返回值加入vector容器
428 auto font = Drawing::Font(typeface1, 50.f, 1.0f, 1.0f);
429 font.SetSubpixel(false);
430 font.SetScaleX(1);
431 auto font1 = Drawing::Font(typeface1, 50.f, font.GetScaleX(), 1.0f);
432 font1.SetSubpixel(font.IsSubpixel());
433
434 // 4.创建TextBlob
435 std::string textInfo = "����������������������";
436 std::shared_ptr<Drawing::TextBlob> textBlob = Drawing::TextBlob::MakeFromText(
437 textInfo.c_str(), textInfo.size(), font1, Drawing::TextEncoding::UTF8);
438
439 // 5.组合textBlob类接口,如果有返回值则获取上一步创建的textBlob返回值打印
440 std::string name1 = "HMOS Color Emoji";
441 std::string textInfo1 = "����������������������";
442 std::shared_ptr<Drawing::TextBlob> textBlob1 = Drawing::TextBlob::MakeFromText(textInfo1.c_str(),
443 textInfo1.size(), font1, Drawing::TextEncoding::UTF8);
444 if (textBlob1->IsEmoji()) {
445 playbackCanvas_->DrawBackground(0xFF0000FF);
446 } else {
447 playbackCanvas_->DrawBackground(0xFFFF0000);
448 }
449
450 //6. 得到需要绘制的所有返回值text,全部适应固定的textBlob构造方式打印
451 std::vector<std::string> texts = {};
452
453 //7.调用ClipIRect截取(0,0,1000,1000)区域（缺省,默认INTERSECT、不抗锯齿）
454
455 //8.调用Scale,Rotate,ConcatMatrix
456 playbackCanvas_->Rotate(45, 50, 50);
457 playbackCanvas_->Scale(0.5, 0.5);
458
459 //9.最终绘制
460 DrawTextBlob(texts, textBlob, font1, playbackCanvas_);
461 }
462
463 // 用例 Font_Scene_Transform_0010
464 DEF_DTK(Font_Scene_Transform_1, TestLevel::L2, 10)
465 {
466 // 1.创建typeface
467 std::shared_ptr<Drawing::Typeface> typeface = Drawing::Typeface::MakeFromFile("/system/fonts/HarmonyOS_Sans.ttf");
468 // 2.组合typeface操作接口
469 typeface->SetHash(100);
470 std::string typefacestr = "GetHash = " + std::to_string(typeface->GetHash());;
471 // 3.组合Font类接口,如果是操作类有返回值的接口,获取接口返回值加入vector容器
472 auto font1 = Drawing::Font(typeface, 50.f, 1.0f, 1.0f);
473 font1.SetSubpixel(false);
474 std::string text0 = "DDGR ddgr 鸿蒙 !@#￥%^&*; : , 。";
475 int glyphCount = font1.CountText(text0.c_str(), text0.length(), Drawing::TextEncoding::UTF16);
476 uint16_t glyphs[glyphCount - 1];
477 int count = font1.TextToGlyphs(text0.c_str(), text0.length(), Drawing::TextEncoding::UTF16, glyphs, glyphCount + 1);
478 std::string text4 = "TextToGlyphs = " + std::to_string(count);
479
480 // 4.创建TextBlob
481 std::string textInfo = "����������������������";
482 std::shared_ptr<Drawing::TextBlob> textBlob = Drawing::TextBlob::MakeFromText(
483 textInfo.c_str(), textInfo.size(), font1, Drawing::TextEncoding::UTF8);
484
485 // 5.组合textBlob类接口,如果有返回值则获取上一步创建的textBlob返回值打印
486 auto rect = textBlob->Bounds();
487 playbackCanvas_->DrawRect(*rect);
488
489 //6. 得到需要绘制的所有返回值text,全部适应固定的textBlob构造方式打印
490 std::vector<std::string> texts = {typefacestr, text4};
491
492 //7.调用ClipIRect截取(0,0,1000,1000)区域（缺省,默认INTERSECT、不抗锯齿）
493 Drawing::Path path;
494 path.AddOval({100, 100, 356, 356});
495 playbackCanvas_->ClipPath(path);
496
497 //8.调用Scale,Rotate,ConcatMatrix
498 Drawing::Matrix matrix;
499 playbackCanvas_->ConcatMatrix(matrix);
500 playbackCanvas_->Scale(0.5, 0.5);
501 playbackCanvas_->Translate(400, 600);
502
503 //9.最终绘制
504 DrawTextBlob(texts, textBlob, font1, playbackCanvas_);
505 }
506
507 // 用例 Font_Scene_Transform_0011
508 DEF_DTK(Font_Scene_Transform_1, TestLevel::L2, 11)
509 {
510 // 1.创建typeface
511 std::shared_ptr<Drawing::Typeface> typeface = Drawing::Typeface::MakeFromFile("/system/fonts/HarmonyOS_Sans.ttf");
512 // 2.组合typeface操作接口
513 std::string typefacestr = "GetUniqueID = " + std::to_string(typeface->GetUniqueID());
514 // 3.组合Font类接口,如果是操作类有返回值的接口,获取接口返回值加入vector容器
515 auto font = Drawing::Font(typeface, 50.f, 1.0f, 1.0f);
516 font.SetSubpixel(false);
517 font.SetTypeface(typeface);
518 auto font1 = Drawing::Font(font.GetTypeface(), 50.f, 1.0f, 1.0f);
519 font1.SetSubpixel(font.IsSubpixel());
520
521 // 4.创建TextBlob
522 std::string textInfo = "harmony_os";
523 int cont = textInfo.size();
524 Drawing::Point p[cont];
525 for (int i = 0; i < cont; i++) {
526 p[i].SetX(-100 + 50 * i);
527 p[i].SetY(1000 - 50 * i);
528 }
529 std::shared_ptr<Drawing::TextBlob> textBlob = Drawing::TextBlob::MakeFromPosText(
530 textInfo.c_str(), 10, p, font1, Drawing::TextEncoding::UTF8);
531
532 // 5.组合textBlob类接口,如果有返回值则获取上一步创建的textBlob返回值打印
533 std::string textinfo1 = "Deserialize @Hello World";
534 Drawing::TextBlob::Context* Ctx = new (std::nothrow) Drawing::TextBlob::Context(typeface, false);
535 auto data2 = textBlob->Serialize(Ctx);
536 std::shared_ptr<Drawing::TextBlob> infoTextBlob2 =
537 Drawing::TextBlob::Deserialize(data2->GetData(), data2->GetSize(), Ctx);
538
539 //6. 得到需要绘制的所有返回值text,全部适应固定的textBlob构造方式打印
540 std::vector<std::string> texts = {typefacestr};
541
542 //7.调用ClipIRect截取(0,0,1000,1000)区域（缺省,默认INTERSECT、不抗锯齿）
543
544 //8.调用Scale,Rotate,ConcatMatrix
545 Drawing::Matrix matrix;
546 playbackCanvas_->ConcatMatrix(matrix);
547 playbackCanvas_->Scale(0.5, 0.5);
548
549 //9.最终绘制
550 DrawTextBlob(texts, textBlob, font1, playbackCanvas_);
551 }
552
553 // 用例 Font_Scene_Transform_0012
554 DEF_DTK(Font_Scene_Transform_1, TestLevel::L2, 12)
555 {
556 // 1.创建typeface
557 std::shared_ptr<Drawing::Typeface> typeface = Drawing::Typeface::MakeFromFile("/system/fonts/HarmonyOS_Sans.ttf");
558 // 2.组合typeface操作接口
559 typeface->SetHash(100);
560 std::string typefacestr = "GetHash = " + std::to_string(typeface->GetHash());;
561 // 3.组合Font类接口,如果是操作类有返回值的接口,获取接口返回值加入vector容器
562 auto font = Drawing::Font(typeface, 50.f, 1.0f, 1.0f);
563 font.SetSubpixel(false);
564 font.SetSkewX(1.0f);
565 auto font1 = Drawing::Font(typeface, 50.f, font.GetSkewX(), 1.0f);
566 font1.SetSubpixel(font.IsSubpixel());
567
568 // 4.创建TextBlob
569 std::string textInfo = "harmony_os";
570 int cont = textInfo.size();
571 Drawing::Point p[cont];
572 for (int i = 0; i < cont; i++) {
573 p[i].SetX(-100 + 50 * i);
574 p[i].SetY(1000 - 50 * i);
575 }
576 std::shared_ptr<Drawing::TextBlob> textBlob = Drawing::TextBlob::MakeFromPosText(
577 textInfo.c_str(), 10, p, font1, Drawing::TextEncoding::UTF8);
578
579 // 5.组合textBlob类接口,如果有返回值则获取上一步创建的textBlob返回值打印
580 std::string name1 = "HMOS Color Emoji";
581 std::string textInfo1 = "����������������������";
582 std::shared_ptr<Drawing::TextBlob> textBlob1 = Drawing::TextBlob::MakeFromText(textInfo1.c_str(),
583 textInfo1.size(), font1, Drawing::TextEncoding::UTF8);
584 if (textBlob1->IsEmoji()) {
585 playbackCanvas_->DrawBackground(0xFF0000FF);
586 } else {
587 playbackCanvas_->DrawBackground(0xFFFF0000);
588 }
589
590 //6. 得到需要绘制的所有返回值text,全部适应固定的textBlob构造方式打印
591 std::vector<std::string> texts = {typefacestr};
592
593 //7.调用ClipIRect截取(0,0,1000,1000)区域（缺省,默认INTERSECT、不抗锯齿）
594 auto rect1 = Drawing::Rect(0, 0, 600, 600);
595 playbackCanvas_->ClipRect(rect1);
596
597 //8.调用Scale,Rotate,ConcatMatrix
598 playbackCanvas_->Scale(0.5, 0.5);
599 playbackCanvas_->Translate(400, 600);
600
601 //9.最终绘制
602 DrawTextBlob(texts, textBlob, font1, playbackCanvas_);
603 }
604
605 // 用例 Font_Scene_Transform_0013
606 DEF_DTK(Font_Scene_Transform_1, TestLevel::L2, 13)
607 {
608 // 1.创建typeface
609 std::shared_ptr<Drawing::Typeface> typeface = Drawing::Typeface::MakeFromFile("/system/fonts/HarmonyOS_Sans.ttf");
610 // 2.组合typeface操作接口
611 auto data = typeface->Serialize();
612 uint32_t size = 10;
613 typeface->SetSize(size);
614 std::shared_ptr<Drawing::Typeface> typeface1 = Drawing::Typeface::Deserialize(data->GetData(), typeface->GetSize());
615 // 3.组合Font类接口,如果是操作类有返回值的接口,获取接口返回值加入vector容器
616 auto font1 = Drawing::Font(typeface1, 50.f, 1.0f, 1.0f);
617 font1.SetSubpixel(false);
618 std::string text0 = "DDGR ddgr 鸿蒙 !@#￥%^&*; : , 。";
619 Drawing::Rect bounds;
620 auto scalar = font1.MeasureText(text0.c_str(), text0.length(), Drawing::TextEncoding::UTF32, &bounds);
621 std::string text4 = "MeasureTextWidths = " + std::to_string(scalar);
622
623 // 4.创建TextBlob
624 std::string textInfo = "harmony_os";
625 int cont = textInfo.size();
626 Drawing::Point p[cont];
627 for (int i = 0; i < cont; i++) {
628 p[i].SetX(-100 + 50 * i);
629 p[i].SetY(1000 - 50 * i);
630 }
631 std::shared_ptr<Drawing::TextBlob> textBlob = Drawing::TextBlob::MakeFromPosText(
632 textInfo.c_str(), 10, p, font1, Drawing::TextEncoding::UTF8);
633
634 // 5.组合textBlob类接口,如果有返回值则获取上一步创建的textBlob返回值打印
635 std::string text = "harmony_os";
636 std::vector<uint16_t> glyphid;
637 Drawing::TextBlob::GetDrawingGlyphIDforTextBlob(textBlob.get(), glyphid);
638 playbackCanvas_->Translate(200, 200);
639 for (int row = 0; row < text.size() && row < glyphid.size(); row++) {
640 auto path = Drawing::TextBlob::GetDrawingPathforTextBlob(glyphid[row], textBlob.get());
641 playbackCanvas_->DrawPath(path);
642 playbackCanvas_->Translate(0, 100);
643 }
644
645 //6. 得到需要绘制的所有返回值text,全部适应固定的textBlob构造方式打印
646 std::vector<std::string> texts = {text4};
647
648 //7.调用ClipIRect截取(0,0,1000,1000)区域（缺省,默认INTERSECT、不抗锯齿）
649 auto rrect = Drawing::RoundRect(Drawing::Rect(0, 0, 1000, 1000), 52, 52);
650 playbackCanvas_->ClipRoundRect(rrect);
651
652 //8.调用Scale,Rotate,ConcatMatrix
653 playbackCanvas_->Rotate(45, 50, 50);
654 playbackCanvas_->Translate(400, 600);
655
656 //9.最终绘制
657 DrawTextBlob(texts, textBlob, font1, playbackCanvas_);
658 }
659
660 // 用例 Font_Scene_Transform_0014
661 DEF_DTK(Font_Scene_Transform_1, TestLevel::L2, 14)
662 {
663 // 1.创建typeface
664 std::shared_ptr<Drawing::Typeface> typeface = Drawing::Typeface::MakeFromFile("/system/fonts/HarmonyOS_Sans.ttf");
665 // 2.组合typeface操作接口
666 std::string typefacestr = "GetUnitsPerEm = " + std::to_string(typeface->GetUnitsPerEm());
667 // 3.组合Font类接口,如果是操作类有返回值的接口,获取接口返回值加入vector容器
668 auto font = Drawing::Font(typeface, 50.f, 1.0f, 1.0f);
669 font.SetSubpixel(false);
670 font.SetSize(100.f);
671 auto font1 = Drawing::Font(typeface, font.GetSize(), 1.0f, 1.0f);
672 font1.SetSubpixel(font.IsSubpixel());
673
674 // 4.创建TextBlob
675 std::string textInfo = "harmony_os";
676 std::shared_ptr<Drawing::TextBlob> textBlob = Drawing::TextBlob::MakeFromString(
677 textInfo.c_str(), font1, Drawing::TextEncoding::UTF8);
678
679 // 5.组合textBlob类接口,如果有返回值则获取上一步创建的textBlob返回值打印
680 std::string name1 = "HMOS Color Emoji";
681 std::string textInfo1 = "����������������������";
682 std::shared_ptr<Drawing::TextBlob> textBlob1 = Drawing::TextBlob::MakeFromText(textInfo1.c_str(),
683 textInfo1.size(), font1, Drawing::TextEncoding::UTF8);
684 if (textBlob1->IsEmoji()) {
685 playbackCanvas_->DrawBackground(0xFF0000FF);
686 } else {
687 playbackCanvas_->DrawBackground(0xFFFF0000);
688 }
689
690 //6. 得到需要绘制的所有返回值text,全部适应固定的textBlob构造方式打印
691 std::vector<std::string> texts = {typefacestr};
692
693 //7.调用ClipIRect截取(0,0,1000,1000)区域（缺省,默认INTERSECT、不抗锯齿）
694 auto rect1 = Drawing::RectI(0, 0, 1000, 1000);
695 playbackCanvas_->ClipIRect(rect1, Drawing::ClipOp::INTERSECT);
696
697 //8.调用Scale,Rotate,ConcatMatrix
698 Drawing::Matrix matrix;
699 playbackCanvas_->ConcatMatrix(matrix);
700 playbackCanvas_->Translate(400, 600);
701
702 //9.最终绘制
703 DrawTextBlob(texts, textBlob, font1, playbackCanvas_);
704 }
705
706 // 用例 Font_Scene_Transform_0015
707 DEF_DTK(Font_Scene_Transform_1, TestLevel::L2, 15)
708 {
709 // 1.创建typeface
710 std::shared_ptr<Drawing::Typeface> typeface = Drawing::Typeface::MakeFromFile("/system/fonts/HarmonyOS_Sans.ttf");
711 // 2.组合typeface操作接口
712 std::string typefacestr = "GetItalic = " + std::to_string(typeface->GetItalic());
713 // 3.组合Font类接口,如果是操作类有返回值的接口,获取接口返回值加入vector容器
714 auto font = Drawing::Font(typeface, 50.f, 1.0f, 1.0f);
715 font.SetSubpixel(false);
716 font.SetLinearMetrics(false);
717 auto font1 = Drawing::Font(typeface, 50.f, 1.0f, 1.0f);
718 font1.SetSubpixel(font.IsSubpixel());
719 font1.SetLinearMetrics(font.IsLinearMetrics());
720
721 // 4.创建TextBlob
722 std::string textInfo = "harmony_os";
723 std::shared_ptr<Drawing::TextBlob> textBlob = Drawing::TextBlob::MakeFromString(
724 textInfo.c_str(), font1, Drawing::TextEncoding::UTF8);
725
726 // 5.组合textBlob类接口,如果有返回值则获取上一步创建的textBlob返回值打印
727 Drawing::Paint paint;
728 paint.SetColor(0xFFFF0000);
729 float boundsx[] = {1, 2, 3};
730 int intercepts = textBlob->GetIntercepts(boundsx, nullptr, &paint);
731 std::string text2 = "intercepts = " + std::to_string(intercepts);
732
733 //6. 得到需要绘制的所有返回值text,全部适应固定的textBlob构造方式打印
734 std::vector<std::string> texts = {typefacestr, text2};
735
736 //7.调用ClipIRect截取(0,0,1000,1000)区域（缺省,默认INTERSECT、不抗锯齿）
737
738 //8.调用Scale,Rotate,ConcatMatrix
739 playbackCanvas_->Rotate(45, 50, 50);
740
741 //9.最终绘制
742 DrawTextBlob(texts, textBlob, font1, playbackCanvas_);
743 }
744
745 // 用例 Font_Scene_Transform_0016
746 DEF_DTK(Font_Scene_Transform_1, TestLevel::L2, 16)
747 {
748 // 1.创建typeface
749 std::shared_ptr<Drawing::Typeface> typeface = Drawing::Typeface::MakeFromFile("/system/fonts/HarmonyOS_Sans.ttf");
750 // 2.组合typeface操作接口
751 auto familyNamex = typeface->GetFamilyName();
752 std::string typefacestr = "GetFamilyName = " + familyNamex;
753 // 3.组合Font类接口,如果是操作类有返回值的接口,获取接口返回值加入vector容器
754 auto font1 = Drawing::Font(typeface, 50.f, 1.0f, 1.0f);
755 font1.SetSubpixel(false);
756 std::string text0 = "DDGR ddgr 鸿蒙 !@#￥%^&*; : , 。";
757 auto SpaceLine = font1.MeasureSingleCharacter(0x44);
758 std::string text4 = "Recommended spacing between lines = " + std::to_string(SpaceLine);
759
760 // 4.创建TextBlob
761 std::string textInfo = "harmony_os";
762 std::shared_ptr<Drawing::TextBlob> textBlob = Drawing::TextBlob::MakeFromString(
763 textInfo.c_str(), font1, Drawing::TextEncoding::UTF8);
764
765 // 5.组合textBlob类接口,如果有返回值则获取上一步创建的textBlob返回值打印
766 std::string name1 = "HMOS Color Emoji";
767 std::string textInfo1 = "����������������������";
768 std::shared_ptr<Drawing::TextBlob> textBlob1 = Drawing::TextBlob::MakeFromText(textInfo1.c_str(),
769 textInfo1.size(), font1, Drawing::TextEncoding::UTF8);
770 if (textBlob1->IsEmoji()) {
771 playbackCanvas_->DrawBackground(0xFF0000FF);
772 } else {
773 playbackCanvas_->DrawBackground(0xFFFF0000);
774 }
775
776 //6. 得到需要绘制的所有返回值text,全部适应固定的textBlob构造方式打印
777 std::vector<std::string> texts = {typefacestr, text4};
778
779 //7.调用ClipIRect截取(0,0,1000,1000)区域（缺省,默认INTERSECT、不抗锯齿）
780 Drawing::Region region;
781 region.SetRect(Drawing::RectI(100, 100, 500, 500));
782 playbackCanvas_->ClipRegion(region);
783
784 //8.调用Scale,Rotate,ConcatMatrix
785 Drawing::Matrix matrix;
786 playbackCanvas_->ConcatMatrix(matrix);
787 playbackCanvas_->Rotate(45, 50, 50);
788 playbackCanvas_->Scale(0.5, 0.5);
789 playbackCanvas_->Translate(400, 600);
790
791 //9.最终绘制
792 DrawTextBlob(texts, textBlob, font1, playbackCanvas_);
793 }
794
795 // 用例 Font_Scene_Transform_0017
796 DEF_DTK(Font_Scene_Transform_1, TestLevel::L2, 17)
797 {
798 // 1.创建typeface
799 std::shared_ptr<Drawing::Typeface> typeface = Drawing::Typeface::MakeFromFile("/system/fonts/HarmonyOS_Sans.ttf");
800 // 2.组合typeface操作接口
801 std::string typefacestr = "IsCustomTypeface = " + std::to_string(typeface->IsCustomTypeface());
802 // 3.组合Font类接口,如果是操作类有返回值的接口,获取接口返回值加入vector容器
803 auto font = Drawing::Font(typeface, 50.f, 1.0f, 1.0f);
804 font.SetSubpixel(false);
805 font.SetEmbolden(false);
806 auto font1 = Drawing::Font(typeface, 50.f, 1.0f, 1.0f);
807 font1.SetSubpixel(font.IsSubpixel());
808 font1.SetEmbolden(font.IsEmbolden());
809
810 // 4.创建TextBlob
811 std::string textInfo = "1111111111111111111111111111111111";
812 int maxGlyphCount = font1.CountText(textInfo.c_str(), textInfo.size(), Drawing::TextEncoding::UTF8);
813 Drawing::RSXform xform[maxGlyphCount];
814 for (int i = 0; i < maxGlyphCount; ++i) {
815 xform[i].cos_ = cos(10 * i) + 0.1 * i;
816 xform[i].sin_ = sin(10 * i);
817 xform[i].tx_ = 40 * i + 100;;
818 xform[i].ty_ = 100;
819 }
820 std::shared_ptr<Drawing::TextBlob> textBlob = Drawing::TextBlob::MakeFromRSXform(
821 textInfo.c_str(), textInfo.size(), &xform[0], font1, Drawing::TextEncoding::UTF8);
822
823 // 5.组合textBlob类接口,如果有返回值则获取上一步创建的textBlob返回值打印
824 Drawing::Paint paint;
825 paint.SetColor(0xFFFF0000);
826 float boundsx[] = {1, 2, 3};
827 int intercepts = textBlob->GetIntercepts(boundsx, nullptr, &paint);
828 std::string text2 = "intercepts = " + std::to_string(intercepts);
829
830 //6. 得到需要绘制的所有返回值text,全部适应固定的textBlob构造方式打印
831 std::vector<std::string> texts = {typefacestr, text2};
832
833 //7.调用ClipIRect截取(0,0,1000,1000)区域（缺省,默认INTERSECT、不抗锯齿）
834 auto rect1 = Drawing::Rect(0, 0, 600, 600);
835 playbackCanvas_->ClipRect(rect1);
836
837 //8.调用Scale,Rotate,ConcatMatrix
838 playbackCanvas_->Rotate(45, 50, 50);
839 playbackCanvas_->Scale(0.5, 0.5);
840
841 //9.最终绘制
842 DrawTextBlob(texts, textBlob, font1, playbackCanvas_);
843 }
844
845 // 用例 Font_Scene_Transform_0019
846 DEF_DTK(Font_Scene_Transform_1, TestLevel::L2, 19)
847 {
848 // 1.创建typeface
849 std::shared_ptr<Drawing::Typeface> typeface = Drawing::Typeface::MakeFromFile("/system/fonts/HarmonyOS_Sans.ttf");
850 // 2.组合typeface操作接口
851 std::string typefacestr = "GetUniqueID = " + std::to_string(typeface->GetUniqueID());
852 // 3.组合Font类接口,如果是操作类有返回值的接口,获取接口返回值加入vector容器
853 auto font1 = Drawing::Font(typeface, 50.f, 1.0f, 1.0f);
854 font1.SetSubpixel(false);
855 std::string text0 = "DDGR ddgr 鸿蒙 !@#￥%^&*; : , 。";
856 Drawing::FontMetrics metrics;
857 auto SpaceLine = font1.GetMetrics(&metrics);
858 std::string text4 = "Recommended spacing between lines = " + std::to_string(SpaceLine);
859
860 // 4.创建TextBlob
861 std::string textInfo = "1111111111111111111111111111111111";
862 int maxGlyphCount = font1.CountText(textInfo.c_str(), textInfo.size(), Drawing::TextEncoding::UTF8);
863 Drawing::RSXform xform[maxGlyphCount];
864 for (int i = 0; i < maxGlyphCount; ++i) {
865 xform[i].cos_ = cos(10 * i) + 0.1 * i;
866 xform[i].sin_ = sin(10 * i);
867 xform[i].tx_ = 40 * i + 100;;
868 xform[i].ty_ = 100;
869 }
870 std::shared_ptr<Drawing::TextBlob> textBlob = Drawing::TextBlob::MakeFromRSXform(
871 textInfo.c_str(), textInfo.size(), &xform[0], font1, Drawing::TextEncoding::UTF8);
872
873 // 5.组合textBlob类接口,如果有返回值则获取上一步创建的textBlob返回值打印
874 std::string text = "harmony_os";
875 std::vector<uint16_t> glyphid;
876 Drawing::TextBlob::GetDrawingGlyphIDforTextBlob(textBlob.get(), glyphid);
877 std::string text2 = "";
878 for (int row = 0; row < text.size() && row < glyphid.size(); row++) {
879 text2 += std::string(1, text[row]) + "：" + std::to_string(glyphid[row]);
880 }
881
882 //6. 得到需要绘制的所有返回值text,全部适应固定的textBlob构造方式打印
883 std::vector<std::string> texts = {typefacestr, text2, text4};
884
885 //7.调用ClipIRect截取(0,0,1000,1000)区域（缺省,默认INTERSECT、不抗锯齿）
886 auto rrect = Drawing::RoundRect(Drawing::Rect(0, 0, 1000, 1000), 52, 52);
887 playbackCanvas_->ClipRoundRect(rrect);
888
889 //8.调用Scale,Rotate,ConcatMatrix
890 Drawing::Matrix matrix;
891 playbackCanvas_->ConcatMatrix(matrix);
892 playbackCanvas_->Rotate(45, 50, 50);
893
894 //9.最终绘制
895 DrawTextBlob(texts, textBlob, font1, playbackCanvas_);
896 }
897
898 // 用例 Font_Scene_Transform_0021
899 DEF_DTK(Font_Scene_Transform_1, TestLevel::L2, 21)
900 {
901 // 1.创建typeface
902 auto typeface = Drawing::Typeface::MakeFromFile("/system/fonts/SanJiMengMengCaiSeJianTi-2.ttf");
903 // 2.组合typeface操作接口
904 std::string typefacestr = "GetItalic = " + std::to_string(typeface->GetItalic());
905 // 3.组合Font类接口,如果是操作类有返回值的接口,获取接口返回值加入vector容器
906 auto font = Drawing::Font(typeface, 50.f, 1.0f, 1.0f);
907 font.SetSubpixel(false);
908 font.SetEdging(Drawing::FontEdging::ANTI_ALIAS);
909 auto font1 = Drawing::Font(typeface, 50.f, 1.0f, 1.0f);
910 font1.SetSubpixel(font.IsSubpixel());
911 font1.SetEdging(font.GetEdging());
912
913 // 4.创建TextBlob
914 Drawing::TextBlobBuilder builder;
915 auto buffer = builder.AllocRunPos(font1, 20, nullptr);
916 for (int i = 0; i < 20; i++) {
917 buffer.glyphs[i] = font1.UnicharToGlyph(0x9088);
918 buffer.pos[i * 2] = 50.f * i;
919 buffer.pos[i * 2 + 1] = 0;
920 }
921 std::shared_ptr<Drawing::TextBlob> textBlob = builder.Make();
922
923 // 5.组合textBlob类接口,如果有返回值则获取上一步创建的textBlob返回值打印
924 Drawing::Paint paint;
925 paint.SetColor(0xFFFF0000);
926 float boundsx[] = {1, 2, 3};
927 int intercepts = textBlob->GetIntercepts(boundsx, nullptr, &paint);
928 std::string text2 = "intercepts = " + std::to_string(intercepts);
929
930 //6. 得到需要绘制的所有返回值text,全部适应固定的textBlob构造方式打印
931 std::vector<std::string> texts = {typefacestr, text2};
932
933 //7.调用ClipIRect截取(0,0,1000,1000)区域（缺省,默认INTERSECT、不抗锯齿）
934 auto rrect = Drawing::RoundRect(Drawing::Rect(0, 0, 1000, 1000), 52, 52);
935 playbackCanvas_->ClipRoundRect(rrect);
936
937 //8.调用Scale,Rotate,ConcatMatrix
938 playbackCanvas_->Scale(0.5, 0.5);
939
940 //9.最终绘制
941 DrawTextBlob(texts, textBlob, font1, playbackCanvas_);
942 }
943
944 // 用例 Font_Scene_Transform_0022
945 DEF_DTK(Font_Scene_Transform_1, TestLevel::L2, 22)
946 {
947 // 1.创建typeface
948 auto typeface = Drawing::Typeface::MakeFromFile("/system/fonts/SanJiMengMengCaiSeJianTi-2.ttf");
949 // 2.组合typeface操作接口
950 auto data = typeface->Serialize();
951 uint32_t size = 10;
952 typeface->SetSize(size);
953 std::shared_ptr<Drawing::Typeface> typeface1 = Drawing::Typeface::Deserialize(data->GetData(), typeface->GetSize());
954 // 3.组合Font类接口,如果是操作类有返回值的接口,获取接口返回值加入vector容器
955 auto font = Drawing::Font(typeface1, 50.f, 1.0f, 1.0f);
956 font.SetSubpixel(false);
957 font.SetSize(100.f);
958 auto font1 = Drawing::Font(typeface1, font.GetSize(), 1.0f, 1.0f);
959 font1.SetSubpixel(font.IsSubpixel());
960
961 // 4.创建TextBlob
962 Drawing::TextBlobBuilder builder;
963 auto buffer = builder.AllocRunPos(font1, 20, nullptr);
964 for (int i = 0; i < 20; i++) {
965 buffer.glyphs[i] = font1.UnicharToGlyph(0x9088);
966 buffer.pos[i * 2] = 50.f * i;
967 buffer.pos[i * 2 + 1] = 0;
968 }
969 std::shared_ptr<Drawing::TextBlob> textBlob = builder.Make();
970
971 // 5.组合textBlob类接口,如果有返回值则获取上一步创建的textBlob返回值打印
972 std::vector<Drawing::Point> points;
973 Drawing::TextBlob::GetDrawingPointsForTextBlob(textBlob.get(), points);
974 std::string text2 = "";
975 for (int i = 0; i < points.size(); i++) {
976 text2 += std::to_string(i) + "-- X：" + std::to_string(points[i].GetX())
977 + "Y：" + std::to_string(points[i].GetY());
978 }
979
980 //6. 得到需要绘制的所有返回值text,全部适应固定的textBlob构造方式打印
981 std::vector<std::string> texts = {text2};
982
983 //7.调用ClipIRect截取(0,0,1000,1000)区域（缺省,默认INTERSECT、不抗锯齿）
984 auto rect1 = Drawing::RectI(0, 0, 1000, 1000);
985 playbackCanvas_->ClipIRect(rect1, Drawing::ClipOp::INTERSECT);
986
987 //8.调用Scale,Rotate,ConcatMatrix
988 playbackCanvas_->Rotate(45, 50, 50);
989 playbackCanvas_->Scale(0.5, 0.5);
990 playbackCanvas_->Translate(400, 600);
991
992 //9.最终绘制
993 DrawTextBlob(texts, textBlob, font1, playbackCanvas_);
994 }
995
996 }
997 }
998