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