automated-tests/src/dali-toolkit-internal/utc-Dali-Text-Hyphen-Wrapping.cpp

   1 /*
   2  * Copyright (c) 2022 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 #include <stdlib.h>
  19 #include <unistd.h>
  20 #include <iostream>
  21
  22 #include <dali-toolkit-test-suite-utils.h>
  23 #include <dali-toolkit/dali-toolkit.h>
  24 #include <dali-toolkit/internal/text/layouts/layout-engine.h>
  25 #include <dali-toolkit/internal/text/layouts/layout-parameters.h>
  26 #include <dali-toolkit/internal/text/text-run-container.h>
  27 #include <toolkit-text-utils.h>
  28
  29 using namespace Dali;
  30 using namespace Toolkit;
  31 using namespace Text;
  32
  33 namespace
  34 {
  35 const std::string DEFAULT_FONT_DIR("/resources/fonts");
  36
  37 struct LayoutTextData
  38 {
  39   std::string          text;
  40   Size                 textArea;
  41   unsigned int         numberOfFonts;
  42   FontDescriptionRun*  fontDescriptions;
  43   unsigned int         numberOfLines;
  44   LineRun*             lines;
  45   Layout::Engine::Type layout;
  46   unsigned int         startIndex;
  47   unsigned int         numberOfGlyphs;
  48   Text::LineWrap::Mode wrapMode;
  49 };
  50
  51 void Print(const LineRun& line)
  52 {
  53   std::cout << "        glyph run, index : " << line.glyphRun.glyphIndex << ", num glyphs : " << line.glyphRun.numberOfGlyphs << std::endl;
  54   std::cout << "    character run, index : " << line.characterRun.characterIndex << ", num chars : " << line.characterRun.numberOfCharacters << std::endl;
  55 }
  56
  57 bool LayoutTextTest(const LayoutTextData& data)
  58 {
  59   // Load some fonts.
  60   TextAbstraction::FontClient fontClient = TextAbstraction::FontClient::Get();
  61   fontClient.SetDpi(96u, 96u);
  62
  63   char*             pathNamePtr = get_current_dir_name();
  64   const std::string pathName(pathNamePtr);
  65   free(pathNamePtr);
  66
  67   fontClient.GetFontId(pathName + DEFAULT_FONT_DIR + "/tizen/TizenSansRegular.ttf");
  68
  69   // 1) Create the model.
  70   ModelPtr   textModel;
  71   MetricsPtr metrics;
  72   Size       layoutSize;
  73
  74   Vector<FontDescriptionRun> fontDescriptionRuns;
  75   if(0u != data.numberOfFonts)
  76   {
  77     fontDescriptionRuns.Insert(fontDescriptionRuns.End(),
  78                                data.fontDescriptions,
  79                                data.fontDescriptions + data.numberOfFonts);
  80   }
  81
  82   LayoutOptions options;
  83   options.align = false;
  84   CreateTextModel(data.text,
  85                   data.textArea,
  86                   fontDescriptionRuns,
  87                   options,
  88                   layoutSize,
  89                   textModel,
  90                   metrics,
  91                   false,
  92                   data.wrapMode,
  93                   false,
  94                   Toolkit::DevelText::EllipsisPosition::END,
  95                   0.0f, // lineSpacing
  96                   0.0f  // characterSpacing
  97   );
  98
  99   Vector<LineRun>& lines = textModel->mVisualModel->mLines;
 100
 101   // 4) Compare the results.
 102
 103   if(lines.Count() != data.numberOfLines)
 104   {
 105     std::cout << "  Different number of lines : " << lines.Count() << ", expected : " << data.numberOfLines << std::endl;
 106     return false;
 107   }
 108
 109   for(unsigned int index = 0u; index < data.numberOfLines; ++index)
 110   {
 111     const LineRun& line         = *(lines.Begin() + index);
 112     const LineRun& expectedLine = *(data.lines + index);
 113
 114     if(line.characterRun.characterIndex != expectedLine.characterRun.characterIndex)
 115     {
 116       std::cout << "  Different line info for line : " << index << std::endl;
 117       Print(line);
 118       std::cout << "  expected" << std::endl;
 119       Print(expectedLine);
 120       return false;
 121     }
 122     if(line.characterRun.numberOfCharacters != expectedLine.characterRun.numberOfCharacters)
 123     {
 124       std::cout << "  Different line info for line : " << index << std::endl;
 125       Print(line);
 126       std::cout << "  expected" << std::endl;
 127       Print(expectedLine);
 128       return false;
 129     }
 130   }
 131
 132   return true;
 133 }
 134
 135 } // namespace
 136
 137 int UtcDaliTextHyphenWrapping(void)
 138 {
 139   ToolkitTestApplication application;
 140   tet_infoline(" UtcDaliTextHyphenWrapping");
 141
 142   // Layout some lines of left to right text.
 143
 144   const std::string fontFamily("TizenSans");
 145
 146   // Set a known font description
 147   FontDescriptionRun fontDescriptionRun1;
 148   fontDescriptionRun1.characterRun.characterIndex     = 0u;
 149   fontDescriptionRun1.characterRun.numberOfCharacters = 13u;
 150   fontDescriptionRun1.familyLength                    = fontFamily.size();
 151   fontDescriptionRun1.familyName                      = new char[fontDescriptionRun1.familyLength];
 152   memcpy(fontDescriptionRun1.familyName, fontFamily.c_str(), fontDescriptionRun1.familyLength);
 153   fontDescriptionRun1.familyDefined = true;
 154   fontDescriptionRun1.weightDefined = false;
 155   fontDescriptionRun1.widthDefined  = false;
 156   fontDescriptionRun1.slantDefined  = false;
 157   fontDescriptionRun1.sizeDefined   = false;
 158
 159   Vector<FontDescriptionRun> fontDescriptionRuns;
 160   fontDescriptionRuns.PushBack(fontDescriptionRun1);
 161   Size textArea(65.0f, 200.f);
 162
 163   LineRun line1 =
 164     {
 165       {0u, 5u},
 166       {0u, 5u},
 167       0.f,
 168       0.f,
 169       0.f,
 170       0.f,
 171       0.f,
 172       0.f,
 173       false,
 174       false};
 175   LineRun line2 =
 176     {
 177       {5u, 8u},
 178       {5u, 8u},
 179       0.f,
 180       0.f,
 181       0.f,
 182       0.f,
 183       0.f,
 184       0.f,
 185       false,
 186       false};
 187
 188   Vector<LineRun> lines;
 189   lines.PushBack(line1);
 190   lines.PushBack(line2);
 191
 192   LayoutTextData data =
 193     {
 194       "Hi Experiment",
 195       textArea,
 196       1u,
 197       fontDescriptionRuns.Begin(),
 198       2u,
 199       lines.Begin(),
 200       Layout::Engine::MULTI_LINE_BOX,
 201       0u,
 202       13u,
 203       (Text::LineWrap::Mode)DevelText::LineWrap::HYPHENATION};
 204
 205   if(!LayoutTextTest(data))
 206   {
 207     tet_result(TET_FAIL);
 208   }
 209
 210   tet_result(TET_PASS);
 211   END_TEST;
 212 }
 213
 214 int UtcDaliTextMixedWrapping(void)
 215 {
 216   ToolkitTestApplication application;
 217   tet_infoline(" UtcDaliTextMixedWrapping");
 218
 219   // Layout some lines of left to right text.
 220
 221   const std::string fontFamily("DejaVuSans");
 222
 223   // Set a known font description
 224   FontDescriptionRun fontDescriptionRun1;
 225   fontDescriptionRun1.characterRun.characterIndex     = 0u;
 226   fontDescriptionRun1.characterRun.numberOfCharacters = 13u;
 227   fontDescriptionRun1.familyLength                    = fontFamily.size();
 228   fontDescriptionRun1.familyName                      = new char[fontDescriptionRun1.familyLength];
 229   memcpy(fontDescriptionRun1.familyName, fontFamily.c_str(), fontDescriptionRun1.familyLength);
 230   fontDescriptionRun1.familyDefined = true;
 231   fontDescriptionRun1.weightDefined = false;
 232   fontDescriptionRun1.widthDefined  = false;
 233   fontDescriptionRun1.slantDefined  = false;
 234   fontDescriptionRun1.sizeDefined   = false;
 235
 236   Vector<FontDescriptionRun> fontDescriptionRuns;
 237   fontDescriptionRuns.PushBack(fontDescriptionRun1);
 238   Size textArea(72.0f, 200.f);
 239
 240   LineRun line1 =
 241     {
 242       {0u, 3u},
 243       {0u, 3u},
 244       0.f,
 245       0.f,
 246       0.f,
 247       0.f,
 248       0.f,
 249       0.f,
 250       false,
 251       false};
 252   LineRun line2 =
 253     {
 254       {3u, 6u},
 255       {3u, 6u},
 256       0.f,
 257       0.f,
 258       0.f,
 259       0.f,
 260       0.f,
 261       0.f,
 262       false,
 263       false};
 264   LineRun line3 =
 265     {
 266       {9u, 4u},
 267       {9u, 4u},
 268       0.f,
 269       0.f,
 270       0.f,
 271       0.f,
 272       0.f,
 273       0.f,
 274       false,
 275       false};
 276
 277   Vector<LineRun> lines;
 278   lines.PushBack(line1);
 279   lines.PushBack(line2);
 280   lines.PushBack(line3);
 281
 282   LayoutTextData data =
 283     {
 284       "Hi Experiment",
 285       textArea,
 286       1u,
 287       fontDescriptionRuns.Begin(),
 288       3u,
 289       lines.Begin(),
 290       Layout::Engine::MULTI_LINE_BOX,
 291       0u,
 292       13u,
 293       (Text::LineWrap::Mode)DevelText::LineWrap::MIXED};
 294
 295   if(!LayoutTextTest(data))
 296   {
 297     tet_result(TET_FAIL);
 298   }
 299
 300   tet_result(TET_PASS);
 301   END_TEST;
 302 }