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