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