dali-csharp-binder/src/font-client.cpp

   1 /** Copyright (c) 2017 Samsung Electronics Co., Ltd.
   2 *
   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 */
  16 #ifndef CSHARP_FONT_CLIENT
  17 #define CSHARP_FONT_CLIENT
  18 #endif
  19
  20 #include "common.h"
  21 #include <dali/public-api/common/type-traits.h>
  22 #include <dali/devel-api/text-abstraction/font-metrics.h>
  23 #include <dali/devel-api/text-abstraction/font-list.h>
  24 #include <dali/devel-api/text-abstraction/glyph-info.h>
  25 #include <dali/devel-api/text-abstraction/text-abstraction-definitions.h>
  26 #include <dali/devel-api/text-abstraction/font-client.h>
  27
  28 /* Callback for returning strings to C# without leaking memory */
  29 typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
  30 extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback;
  31
  32
  33 typedef std::string FontPath;
  34 typedef std::string FontFamily;
  35 typedef std::string FontStyle;
  36 typedef std::vector<Dali::TextAbstraction::FontDescription> FontList;
  37
  38 typedef uint32_t FontId;
  39 typedef uint32_t PointSize26Dot6;
  40 typedef uint32_t FaceIndex;
  41 typedef uint32_t GlyphIndex;
  42 typedef uint32_t Character;
  43 typedef uint32_t CharacterIndex;
  44 typedef uint32_t Length;
  45 typedef uint32_t BidiInfoIndex;
  46 typedef char     LineBreakInfo;
  47 typedef char     WordBreakInfo;
  48 typedef bool     CharacterDirection;
  49
  50
  51 #ifdef __cplusplus
  52 extern "C" {
  53 #endif
  54
  55
  56 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FontClient_SWIGUpcast(Dali::TextAbstraction::FontClient *jarg1) {
  57     return (Dali::BaseHandle *)jarg1;
  58 }
  59
  60 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FontWidthName_get() {
  61   void * jresult ;
  62   char **result = 0 ;
  63
  64   result = (char **)(char **)Dali::TextAbstraction::FontWidth::Name;
  65   jresult = result;
  66   return jresult;
  67 }
  68
  69
  70 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FontWeightName_get() {
  71   void * jresult ;
  72   char **result = 0 ;
  73
  74   result = (char **)(char **)Dali::TextAbstraction::FontWeight::Name;
  75   jresult = result;
  76   return jresult;
  77 }
  78
  79
  80 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FontSlantName_get() {
  81   void * jresult ;
  82   char **result = 0 ;
  83
  84   result = (char **)(char **)Dali::TextAbstraction::FontSlant::Name;
  85   jresult = result;
  86   return jresult;
  87 }
  88
  89
  90 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FontDescription() {
  91   void * jresult ;
  92   Dali::TextAbstraction::FontDescription *result = 0 ;
  93
  94   {
  95     try {
  96       result = (Dali::TextAbstraction::FontDescription *)new Dali::TextAbstraction::FontDescription();
  97     } catch (std::out_of_range& e) {
  98       {
  99         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 100       };
 101     } catch (std::exception& e) {
 102       {
 103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 104       };
 105     } catch (...) {
 106       {
 107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 108       };
 109     }
 110   }
 111   jresult = (void *)result;
 112   return jresult;
 113 }
 114
 115
 116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FontDescription(void * jarg1) {
 117   Dali::TextAbstraction::FontDescription *arg1 = (Dali::TextAbstraction::FontDescription *) 0 ;
 118
 119   arg1 = (Dali::TextAbstraction::FontDescription *)jarg1;
 120   {
 121     try {
 122       delete arg1;
 123     } catch (std::out_of_range& e) {
 124       {
 125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 126       };
 127     } catch (std::exception& e) {
 128       {
 129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 130       };
 131     } catch (...) {
 132       {
 133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 134       };
 135     }
 136   }
 137 }
 138
 139
 140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontDescription_path_set(void * jarg1, char * jarg2) {
 141   Dali::TextAbstraction::FontDescription *arg1 = (Dali::TextAbstraction::FontDescription *) 0 ;
 142   Dali::TextAbstraction::FontPath *arg2 = 0 ;
 143
 144   arg1 = (Dali::TextAbstraction::FontDescription *)jarg1;
 145   if (!jarg2) {
 146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 147     return ;
 148   }
 149   Dali::TextAbstraction::FontPath arg2_str(jarg2);
 150   arg2 = &arg2_str;
 151   if (arg1) (arg1)->path = *arg2;
 152 }
 153
 154
 155 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_FontDescription_path_get(void * jarg1) {
 156   char * jresult ;
 157   Dali::TextAbstraction::FontDescription *arg1 = (Dali::TextAbstraction::FontDescription *) 0 ;
 158   Dali::TextAbstraction::FontPath *result = 0 ;
 159
 160   arg1 = (Dali::TextAbstraction::FontDescription *)jarg1;
 161   result = (Dali::TextAbstraction::FontPath *) & ((arg1)->path);
 162   jresult = SWIG_csharp_string_callback(result->c_str());
 163   return jresult;
 164 }
 165
 166
 167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontDescription_family_set(void * jarg1, char * jarg2) {
 168   Dali::TextAbstraction::FontDescription *arg1 = (Dali::TextAbstraction::FontDescription *) 0 ;
 169   Dali::TextAbstraction::FontFamily *arg2 = 0 ;
 170
 171   arg1 = (Dali::TextAbstraction::FontDescription *)jarg1;
 172   if (!jarg2) {
 173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 174     return ;
 175   }
 176   Dali::TextAbstraction::FontFamily arg2_str(jarg2);
 177   arg2 = &arg2_str;
 178   if (arg1) (arg1)->family = *arg2;
 179 }
 180
 181
 182 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_FontDescription_family_get(void * jarg1) {
 183   char * jresult ;
 184   Dali::TextAbstraction::FontDescription *arg1 = (Dali::TextAbstraction::FontDescription *) 0 ;
 185   Dali::TextAbstraction::FontFamily *result = 0 ;
 186
 187   arg1 = (Dali::TextAbstraction::FontDescription *)jarg1;
 188   result = (Dali::TextAbstraction::FontFamily *) & ((arg1)->family);
 189   jresult = SWIG_csharp_string_callback(result->c_str());
 190   return jresult;
 191 }
 192
 193
 194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontDescription_width_set(void * jarg1, int jarg2) {
 195   Dali::TextAbstraction::FontDescription *arg1 = (Dali::TextAbstraction::FontDescription *) 0 ;
 196   Dali::TextAbstraction::FontWidth::Type arg2 ;
 197
 198   arg1 = (Dali::TextAbstraction::FontDescription *)jarg1;
 199   arg2 = (Dali::TextAbstraction::FontWidth::Type)jarg2;
 200   if (arg1) (arg1)->width = arg2;
 201 }
 202
 203
 204 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FontDescription_width_get(void * jarg1) {
 205   int jresult ;
 206   Dali::TextAbstraction::FontDescription *arg1 = (Dali::TextAbstraction::FontDescription *) 0 ;
 207   Dali::TextAbstraction::FontWidth::Type result;
 208
 209   arg1 = (Dali::TextAbstraction::FontDescription *)jarg1;
 210   result = (Dali::TextAbstraction::FontWidth::Type) ((arg1)->width);
 211   jresult = (int)result;
 212   return jresult;
 213 }
 214
 215
 216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontDescription_weight_set(void * jarg1, int jarg2) {
 217   Dali::TextAbstraction::FontDescription *arg1 = (Dali::TextAbstraction::FontDescription *) 0 ;
 218   Dali::TextAbstraction::FontWeight::Type arg2 ;
 219
 220   arg1 = (Dali::TextAbstraction::FontDescription *)jarg1;
 221   arg2 = (Dali::TextAbstraction::FontWeight::Type)jarg2;
 222   if (arg1) (arg1)->weight = arg2;
 223 }
 224
 225
 226 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FontDescription_weight_get(void * jarg1) {
 227   int jresult ;
 228   Dali::TextAbstraction::FontDescription *arg1 = (Dali::TextAbstraction::FontDescription *) 0 ;
 229   Dali::TextAbstraction::FontWeight::Type result;
 230
 231   arg1 = (Dali::TextAbstraction::FontDescription *)jarg1;
 232   result = (Dali::TextAbstraction::FontWeight::Type) ((arg1)->weight);
 233   jresult = (int)result;
 234   return jresult;
 235 }
 236
 237
 238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontDescription_slant_set(void * jarg1, int jarg2) {
 239   Dali::TextAbstraction::FontDescription *arg1 = (Dali::TextAbstraction::FontDescription *) 0 ;
 240   Dali::TextAbstraction::FontSlant::Type arg2 ;
 241
 242   arg1 = (Dali::TextAbstraction::FontDescription *)jarg1;
 243   arg2 = (Dali::TextAbstraction::FontSlant::Type)jarg2;
 244   if (arg1) (arg1)->slant = arg2;
 245 }
 246
 247
 248 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FontDescription_slant_get(void * jarg1) {
 249   int jresult ;
 250   Dali::TextAbstraction::FontDescription *arg1 = (Dali::TextAbstraction::FontDescription *) 0 ;
 251   Dali::TextAbstraction::FontSlant::Type result;
 252
 253   arg1 = (Dali::TextAbstraction::FontDescription *)jarg1;
 254   result = (Dali::TextAbstraction::FontSlant::Type) ((arg1)->slant);
 255   jresult = (int)result;
 256   return jresult;
 257 }
 258
 259
 260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FontMetrics__SWIG_0() {
 261   void * jresult ;
 262   Dali::TextAbstraction::FontMetrics *result = 0 ;
 263
 264   {
 265     try {
 266       result = (Dali::TextAbstraction::FontMetrics *)new Dali::TextAbstraction::FontMetrics();
 267     } catch (std::out_of_range& e) {
 268       {
 269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 270       };
 271     } catch (std::exception& e) {
 272       {
 273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 274       };
 275     } catch (...) {
 276       {
 277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 278       };
 279     }
 280   }
 281   jresult = (void *)result;
 282   return jresult;
 283 }
 284
 285
 286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FontMetrics__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
 287   void * jresult ;
 288   float arg1 ;
 289   float arg2 ;
 290   float arg3 ;
 291   float arg4 ;
 292   float arg5 ;
 293   Dali::TextAbstraction::FontMetrics *result = 0 ;
 294
 295   arg1 = (float)jarg1;
 296   arg2 = (float)jarg2;
 297   arg3 = (float)jarg3;
 298   arg4 = (float)jarg4;
 299   arg5 = (float)jarg5;
 300   {
 301     try {
 302       result = (Dali::TextAbstraction::FontMetrics *)new Dali::TextAbstraction::FontMetrics(arg1,arg2,arg3,arg4,arg5);
 303     } catch (std::out_of_range& e) {
 304       {
 305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 306       };
 307     } catch (std::exception& e) {
 308       {
 309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 310       };
 311     } catch (...) {
 312       {
 313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 314       };
 315     }
 316   }
 317   jresult = (void *)result;
 318   return jresult;
 319 }
 320
 321
 322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontMetrics_ascender_set(void * jarg1, float jarg2) {
 323   Dali::TextAbstraction::FontMetrics *arg1 = (Dali::TextAbstraction::FontMetrics *) 0 ;
 324   float arg2 ;
 325
 326   arg1 = (Dali::TextAbstraction::FontMetrics *)jarg1;
 327   arg2 = (float)jarg2;
 328   if (arg1) (arg1)->ascender = arg2;
 329 }
 330
 331
 332 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FontMetrics_ascender_get(void * jarg1) {
 333   float jresult ;
 334   Dali::TextAbstraction::FontMetrics *arg1 = (Dali::TextAbstraction::FontMetrics *) 0 ;
 335   float result;
 336
 337   arg1 = (Dali::TextAbstraction::FontMetrics *)jarg1;
 338   result = (float) ((arg1)->ascender);
 339   jresult = result;
 340   return jresult;
 341 }
 342
 343
 344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontMetrics_descender_set(void * jarg1, float jarg2) {
 345   Dali::TextAbstraction::FontMetrics *arg1 = (Dali::TextAbstraction::FontMetrics *) 0 ;
 346   float arg2 ;
 347
 348   arg1 = (Dali::TextAbstraction::FontMetrics *)jarg1;
 349   arg2 = (float)jarg2;
 350   if (arg1) (arg1)->descender = arg2;
 351 }
 352
 353
 354 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FontMetrics_descender_get(void * jarg1) {
 355   float jresult ;
 356   Dali::TextAbstraction::FontMetrics *arg1 = (Dali::TextAbstraction::FontMetrics *) 0 ;
 357   float result;
 358
 359   arg1 = (Dali::TextAbstraction::FontMetrics *)jarg1;
 360   result = (float) ((arg1)->descender);
 361   jresult = result;
 362   return jresult;
 363 }
 364
 365
 366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontMetrics_height_set(void * jarg1, float jarg2) {
 367   Dali::TextAbstraction::FontMetrics *arg1 = (Dali::TextAbstraction::FontMetrics *) 0 ;
 368   float arg2 ;
 369
 370   arg1 = (Dali::TextAbstraction::FontMetrics *)jarg1;
 371   arg2 = (float)jarg2;
 372   if (arg1) (arg1)->height = arg2;
 373 }
 374
 375
 376 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FontMetrics_height_get(void * jarg1) {
 377   float jresult ;
 378   Dali::TextAbstraction::FontMetrics *arg1 = (Dali::TextAbstraction::FontMetrics *) 0 ;
 379   float result;
 380
 381   arg1 = (Dali::TextAbstraction::FontMetrics *)jarg1;
 382   result = (float) ((arg1)->height);
 383   jresult = result;
 384   return jresult;
 385 }
 386
 387
 388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontMetrics_underlinePosition_set(void * jarg1, float jarg2) {
 389   Dali::TextAbstraction::FontMetrics *arg1 = (Dali::TextAbstraction::FontMetrics *) 0 ;
 390   float arg2 ;
 391
 392   arg1 = (Dali::TextAbstraction::FontMetrics *)jarg1;
 393   arg2 = (float)jarg2;
 394   if (arg1) (arg1)->underlinePosition = arg2;
 395 }
 396
 397
 398 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FontMetrics_underlinePosition_get(void * jarg1) {
 399   float jresult ;
 400   Dali::TextAbstraction::FontMetrics *arg1 = (Dali::TextAbstraction::FontMetrics *) 0 ;
 401   float result;
 402
 403   arg1 = (Dali::TextAbstraction::FontMetrics *)jarg1;
 404   result = (float) ((arg1)->underlinePosition);
 405   jresult = result;
 406   return jresult;
 407 }
 408
 409
 410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontMetrics_underlineThickness_set(void * jarg1, float jarg2) {
 411   Dali::TextAbstraction::FontMetrics *arg1 = (Dali::TextAbstraction::FontMetrics *) 0 ;
 412   float arg2 ;
 413
 414   arg1 = (Dali::TextAbstraction::FontMetrics *)jarg1;
 415   arg2 = (float)jarg2;
 416   if (arg1) (arg1)->underlineThickness = arg2;
 417 }
 418
 419
 420 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FontMetrics_underlineThickness_get(void * jarg1) {
 421   float jresult ;
 422   Dali::TextAbstraction::FontMetrics *arg1 = (Dali::TextAbstraction::FontMetrics *) 0 ;
 423   float result;
 424
 425   arg1 = (Dali::TextAbstraction::FontMetrics *)jarg1;
 426   result = (float) ((arg1)->underlineThickness);
 427   jresult = result;
 428   return jresult;
 429 }
 430
 431
 432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FontMetrics(void * jarg1) {
 433   Dali::TextAbstraction::FontMetrics *arg1 = (Dali::TextAbstraction::FontMetrics *) 0 ;
 434
 435   arg1 = (Dali::TextAbstraction::FontMetrics *)jarg1;
 436   {
 437     try {
 438       delete arg1;
 439     } catch (std::out_of_range& e) {
 440       {
 441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 442       };
 443     } catch (std::exception& e) {
 444       {
 445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 446       };
 447     } catch (...) {
 448       {
 449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 450       };
 451     }
 452   }
 453 }
 454
 455
 456 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LINE_MUST_BREAK_get() {
 457   int jresult ;
 458   int result;
 459
 460   {
 461     try {
 462       result = (int)Dali::TextAbstraction::LINE_MUST_BREAK;
 463     } catch (std::out_of_range& e) {
 464       {
 465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 466       };
 467     } catch (std::exception& e) {
 468       {
 469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 470       };
 471     } catch (...) {
 472       {
 473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 474       };
 475     }
 476   }
 477   jresult = (int)result;
 478   return jresult;
 479 }
 480
 481
 482 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LINE_ALLOW_BREAK_get() {
 483   int jresult ;
 484   int result;
 485
 486   {
 487     try {
 488       result = (int)Dali::TextAbstraction::LINE_ALLOW_BREAK;
 489     } catch (std::out_of_range& e) {
 490       {
 491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 492       };
 493     } catch (std::exception& e) {
 494       {
 495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 496       };
 497     } catch (...) {
 498       {
 499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 500       };
 501     }
 502   }
 503   jresult = (int)result;
 504   return jresult;
 505 }
 506
 507
 508 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LINE_NO_BREAK_get() {
 509   int jresult ;
 510   int result;
 511
 512   {
 513     try {
 514       result = (int)Dali::TextAbstraction::LINE_NO_BREAK;
 515     } catch (std::out_of_range& e) {
 516       {
 517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 518       };
 519     } catch (std::exception& e) {
 520       {
 521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 522       };
 523     } catch (...) {
 524       {
 525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 526       };
 527     }
 528   }
 529   jresult = (int)result;
 530   return jresult;
 531 }
 532
 533
 534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WORD_BREAK_get() {
 535   int jresult ;
 536   int result;
 537
 538   {
 539     try {
 540       result = (int)Dali::TextAbstraction::WORD_BREAK;
 541     } catch (std::out_of_range& e) {
 542       {
 543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 544       };
 545     } catch (std::exception& e) {
 546       {
 547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 548       };
 549     } catch (...) {
 550       {
 551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 552       };
 553     }
 554   }
 555   jresult = (int)result;
 556   return jresult;
 557 }
 558
 559
 560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WORD_NO_BREAK_get() {
 561   int jresult ;
 562   int result;
 563
 564   {
 565     try {
 566       result = (int)Dali::TextAbstraction::WORD_NO_BREAK;
 567     } catch (std::out_of_range& e) {
 568       {
 569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 570       };
 571     } catch (std::exception& e) {
 572       {
 573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 574       };
 575     } catch (...) {
 576       {
 577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 578       };
 579     }
 580   }
 581   jresult = (int)result;
 582   return jresult;
 583 }
 584
 585
 586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBlob_r_set(void * jarg1, unsigned char jarg2) {
 587   Dali::TextAbstraction::VectorBlob *arg1 = (Dali::TextAbstraction::VectorBlob *) 0 ;
 588   unsigned char arg2 ;
 589
 590   arg1 = (Dali::TextAbstraction::VectorBlob *)jarg1;
 591   arg2 = (unsigned char)jarg2;
 592   if (arg1) (arg1)->r = arg2;
 593 }
 594
 595
 596 SWIGEXPORT unsigned char SWIGSTDCALL CSharp_Dali_VectorBlob_r_get(void * jarg1) {
 597   unsigned char jresult ;
 598   Dali::TextAbstraction::VectorBlob *arg1 = (Dali::TextAbstraction::VectorBlob *) 0 ;
 599   unsigned char result;
 600
 601   arg1 = (Dali::TextAbstraction::VectorBlob *)jarg1;
 602   result = (unsigned char) ((arg1)->r);
 603   jresult = result;
 604   return jresult;
 605 }
 606
 607
 608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBlob_g_set(void * jarg1, unsigned char jarg2) {
 609   Dali::TextAbstraction::VectorBlob *arg1 = (Dali::TextAbstraction::VectorBlob *) 0 ;
 610   unsigned char arg2 ;
 611
 612   arg1 = (Dali::TextAbstraction::VectorBlob *)jarg1;
 613   arg2 = (unsigned char)jarg2;
 614   if (arg1) (arg1)->g = arg2;
 615 }
 616
 617
 618 SWIGEXPORT unsigned char SWIGSTDCALL CSharp_Dali_VectorBlob_g_get(void * jarg1) {
 619   unsigned char jresult ;
 620   Dali::TextAbstraction::VectorBlob *arg1 = (Dali::TextAbstraction::VectorBlob *) 0 ;
 621   unsigned char result;
 622
 623   arg1 = (Dali::TextAbstraction::VectorBlob *)jarg1;
 624   result = (unsigned char) ((arg1)->g);
 625   jresult = result;
 626   return jresult;
 627 }
 628
 629
 630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBlob_b_set(void * jarg1, unsigned char jarg2) {
 631   Dali::TextAbstraction::VectorBlob *arg1 = (Dali::TextAbstraction::VectorBlob *) 0 ;
 632   unsigned char arg2 ;
 633
 634   arg1 = (Dali::TextAbstraction::VectorBlob *)jarg1;
 635   arg2 = (unsigned char)jarg2;
 636   if (arg1) (arg1)->b = arg2;
 637 }
 638
 639
 640 SWIGEXPORT unsigned char SWIGSTDCALL CSharp_Dali_VectorBlob_b_get(void * jarg1) {
 641   unsigned char jresult ;
 642   Dali::TextAbstraction::VectorBlob *arg1 = (Dali::TextAbstraction::VectorBlob *) 0 ;
 643   unsigned char result;
 644
 645   arg1 = (Dali::TextAbstraction::VectorBlob *)jarg1;
 646   result = (unsigned char) ((arg1)->b);
 647   jresult = result;
 648   return jresult;
 649 }
 650
 651
 652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBlob_a_set(void * jarg1, unsigned char jarg2) {
 653   Dali::TextAbstraction::VectorBlob *arg1 = (Dali::TextAbstraction::VectorBlob *) 0 ;
 654   unsigned char arg2 ;
 655
 656   arg1 = (Dali::TextAbstraction::VectorBlob *)jarg1;
 657   arg2 = (unsigned char)jarg2;
 658   if (arg1) (arg1)->a = arg2;
 659 }
 660
 661
 662 SWIGEXPORT unsigned char SWIGSTDCALL CSharp_Dali_VectorBlob_a_get(void * jarg1) {
 663   unsigned char jresult ;
 664   Dali::TextAbstraction::VectorBlob *arg1 = (Dali::TextAbstraction::VectorBlob *) 0 ;
 665   unsigned char result;
 666
 667   arg1 = (Dali::TextAbstraction::VectorBlob *)jarg1;
 668   result = (unsigned char) ((arg1)->a);
 669   jresult = result;
 670   return jresult;
 671 }
 672
 673
 674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorBlob() {
 675   void * jresult ;
 676   Dali::TextAbstraction::VectorBlob *result = 0 ;
 677
 678   {
 679     try {
 680       result = (Dali::TextAbstraction::VectorBlob *)new Dali::TextAbstraction::VectorBlob();
 681     } catch (std::out_of_range& e) {
 682       {
 683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 684       };
 685     } catch (std::exception& e) {
 686       {
 687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 688       };
 689     } catch (...) {
 690       {
 691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 692       };
 693     }
 694   }
 695   jresult = (void *)result;
 696   return jresult;
 697 }
 698
 699
 700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorBlob(void * jarg1) {
 701   Dali::TextAbstraction::VectorBlob *arg1 = (Dali::TextAbstraction::VectorBlob *) 0 ;
 702
 703   arg1 = (Dali::TextAbstraction::VectorBlob *)jarg1;
 704   {
 705     try {
 706       delete arg1;
 707     } catch (std::out_of_range& e) {
 708       {
 709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 710       };
 711     } catch (std::exception& e) {
 712       {
 713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 714       };
 715     } catch (...) {
 716       {
 717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 718       };
 719     }
 720   }
 721 }
 722
 723
 724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GlyphInfo__SWIG_0() {
 725   void * jresult ;
 726   Dali::TextAbstraction::GlyphInfo *result = 0 ;
 727
 728   {
 729     try {
 730       result = (Dali::TextAbstraction::GlyphInfo *)new Dali::TextAbstraction::GlyphInfo();
 731     } catch (std::out_of_range& e) {
 732       {
 733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 734       };
 735     } catch (std::exception& e) {
 736       {
 737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 738       };
 739     } catch (...) {
 740       {
 741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 742       };
 743     }
 744   }
 745   jresult = (void *)result;
 746   return jresult;
 747 }
 748
 749
 750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GlyphInfo__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
 751   void * jresult ;
 752   Dali::TextAbstraction::FontId arg1 ;
 753   Dali::TextAbstraction::GlyphIndex arg2 ;
 754   Dali::TextAbstraction::GlyphInfo *result = 0 ;
 755
 756   arg1 = (Dali::TextAbstraction::FontId)jarg1;
 757   arg2 = (Dali::TextAbstraction::GlyphIndex)jarg2;
 758   {
 759     try {
 760       result = (Dali::TextAbstraction::GlyphInfo *)new Dali::TextAbstraction::GlyphInfo(arg1,arg2);
 761     } catch (std::out_of_range& e) {
 762       {
 763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 764       };
 765     } catch (std::exception& e) {
 766       {
 767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 768       };
 769     } catch (...) {
 770       {
 771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 772       };
 773     }
 774   }
 775   jresult = (void *)result;
 776   return jresult;
 777 }
 778
 779
 780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlyphInfo_fontId_set(void * jarg1, unsigned int jarg2) {
 781   Dali::TextAbstraction::GlyphInfo *arg1 = (Dali::TextAbstraction::GlyphInfo *) 0 ;
 782   Dali::TextAbstraction::FontId arg2 ;
 783
 784   arg1 = (Dali::TextAbstraction::GlyphInfo *)jarg1;
 785   arg2 = (Dali::TextAbstraction::FontId)jarg2;
 786   if (arg1) (arg1)->fontId = arg2;
 787 }
 788
 789
 790 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GlyphInfo_fontId_get(void * jarg1) {
 791   unsigned int jresult ;
 792   Dali::TextAbstraction::GlyphInfo *arg1 = (Dali::TextAbstraction::GlyphInfo *) 0 ;
 793   Dali::TextAbstraction::FontId result;
 794
 795   arg1 = (Dali::TextAbstraction::GlyphInfo *)jarg1;
 796   result =  ((arg1)->fontId);
 797   jresult = result;
 798   return jresult;
 799 }
 800
 801
 802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlyphInfo_index_set(void * jarg1, unsigned int jarg2) {
 803   Dali::TextAbstraction::GlyphInfo *arg1 = (Dali::TextAbstraction::GlyphInfo *) 0 ;
 804   Dali::TextAbstraction::GlyphIndex arg2 ;
 805
 806   arg1 = (Dali::TextAbstraction::GlyphInfo *)jarg1;
 807   arg2 = (Dali::TextAbstraction::GlyphIndex)jarg2;
 808   if (arg1) (arg1)->index = arg2;
 809 }
 810
 811
 812 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GlyphInfo_index_get(void * jarg1) {
 813   unsigned int jresult ;
 814   Dali::TextAbstraction::GlyphInfo *arg1 = (Dali::TextAbstraction::GlyphInfo *) 0 ;
 815   Dali::TextAbstraction::GlyphIndex result;
 816
 817   arg1 = (Dali::TextAbstraction::GlyphInfo *)jarg1;
 818   result =  ((arg1)->index);
 819   jresult = result;
 820   return jresult;
 821 }
 822
 823
 824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlyphInfo_width_set(void * jarg1, float jarg2) {
 825   Dali::TextAbstraction::GlyphInfo *arg1 = (Dali::TextAbstraction::GlyphInfo *) 0 ;
 826   float arg2 ;
 827
 828   arg1 = (Dali::TextAbstraction::GlyphInfo *)jarg1;
 829   arg2 = (float)jarg2;
 830   if (arg1) (arg1)->width = arg2;
 831 }
 832
 833
 834 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GlyphInfo_width_get(void * jarg1) {
 835   float jresult ;
 836   Dali::TextAbstraction::GlyphInfo *arg1 = (Dali::TextAbstraction::GlyphInfo *) 0 ;
 837   float result;
 838
 839   arg1 = (Dali::TextAbstraction::GlyphInfo *)jarg1;
 840   result = (float) ((arg1)->width);
 841   jresult = result;
 842   return jresult;
 843 }
 844
 845
 846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlyphInfo_height_set(void * jarg1, float jarg2) {
 847   Dali::TextAbstraction::GlyphInfo *arg1 = (Dali::TextAbstraction::GlyphInfo *) 0 ;
 848   float arg2 ;
 849
 850   arg1 = (Dali::TextAbstraction::GlyphInfo *)jarg1;
 851   arg2 = (float)jarg2;
 852   if (arg1) (arg1)->height = arg2;
 853 }
 854
 855
 856 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GlyphInfo_height_get(void * jarg1) {
 857   float jresult ;
 858   Dali::TextAbstraction::GlyphInfo *arg1 = (Dali::TextAbstraction::GlyphInfo *) 0 ;
 859   float result;
 860
 861   arg1 = (Dali::TextAbstraction::GlyphInfo *)jarg1;
 862   result = (float) ((arg1)->height);
 863   jresult = result;
 864   return jresult;
 865 }
 866
 867
 868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlyphInfo_xBearing_set(void * jarg1, float jarg2) {
 869   Dali::TextAbstraction::GlyphInfo *arg1 = (Dali::TextAbstraction::GlyphInfo *) 0 ;
 870   float arg2 ;
 871
 872   arg1 = (Dali::TextAbstraction::GlyphInfo *)jarg1;
 873   arg2 = (float)jarg2;
 874   if (arg1) (arg1)->xBearing = arg2;
 875 }
 876
 877
 878 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GlyphInfo_xBearing_get(void * jarg1) {
 879   float jresult ;
 880   Dali::TextAbstraction::GlyphInfo *arg1 = (Dali::TextAbstraction::GlyphInfo *) 0 ;
 881   float result;
 882
 883   arg1 = (Dali::TextAbstraction::GlyphInfo *)jarg1;
 884   result = (float) ((arg1)->xBearing);
 885   jresult = result;
 886   return jresult;
 887 }
 888
 889
 890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlyphInfo_yBearing_set(void * jarg1, float jarg2) {
 891   Dali::TextAbstraction::GlyphInfo *arg1 = (Dali::TextAbstraction::GlyphInfo *) 0 ;
 892   float arg2 ;
 893
 894   arg1 = (Dali::TextAbstraction::GlyphInfo *)jarg1;
 895   arg2 = (float)jarg2;
 896   if (arg1) (arg1)->yBearing = arg2;
 897 }
 898
 899
 900 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GlyphInfo_yBearing_get(void * jarg1) {
 901   float jresult ;
 902   Dali::TextAbstraction::GlyphInfo *arg1 = (Dali::TextAbstraction::GlyphInfo *) 0 ;
 903   float result;
 904
 905   arg1 = (Dali::TextAbstraction::GlyphInfo *)jarg1;
 906   result = (float) ((arg1)->yBearing);
 907   jresult = result;
 908   return jresult;
 909 }
 910
 911
 912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlyphInfo_advance_set(void * jarg1, float jarg2) {
 913   Dali::TextAbstraction::GlyphInfo *arg1 = (Dali::TextAbstraction::GlyphInfo *) 0 ;
 914   float arg2 ;
 915
 916   arg1 = (Dali::TextAbstraction::GlyphInfo *)jarg1;
 917   arg2 = (float)jarg2;
 918   if (arg1) (arg1)->advance = arg2;
 919 }
 920
 921
 922 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GlyphInfo_advance_get(void * jarg1) {
 923   float jresult ;
 924   Dali::TextAbstraction::GlyphInfo *arg1 = (Dali::TextAbstraction::GlyphInfo *) 0 ;
 925   float result;
 926
 927   arg1 = (Dali::TextAbstraction::GlyphInfo *)jarg1;
 928   result = (float) ((arg1)->advance);
 929   jresult = result;
 930   return jresult;
 931 }
 932
 933
 934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlyphInfo_scaleFactor_set(void * jarg1, float jarg2) {
 935   Dali::TextAbstraction::GlyphInfo *arg1 = (Dali::TextAbstraction::GlyphInfo *) 0 ;
 936   float arg2 ;
 937
 938   arg1 = (Dali::TextAbstraction::GlyphInfo *)jarg1;
 939   arg2 = (float)jarg2;
 940   if (arg1) (arg1)->scaleFactor = arg2;
 941 }
 942
 943
 944 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GlyphInfo_scaleFactor_get(void * jarg1) {
 945   float jresult ;
 946   Dali::TextAbstraction::GlyphInfo *arg1 = (Dali::TextAbstraction::GlyphInfo *) 0 ;
 947   float result;
 948
 949   arg1 = (Dali::TextAbstraction::GlyphInfo *)jarg1;
 950   result = (float) ((arg1)->scaleFactor);
 951   jresult = result;
 952   return jresult;
 953 }
 954
 955
 956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GlyphInfo(void * jarg1) {
 957   Dali::TextAbstraction::GlyphInfo *arg1 = (Dali::TextAbstraction::GlyphInfo *) 0 ;
 958
 959   arg1 = (Dali::TextAbstraction::GlyphInfo *)jarg1;
 960   {
 961     try {
 962       delete arg1;
 963     } catch (std::out_of_range& e) {
 964       {
 965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 966       };
 967     } catch (std::exception& e) {
 968       {
 969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 970       };
 971     } catch (...) {
 972       {
 973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 974       };
 975     }
 976   }
 977 }
 978
 979
 980 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_DEFAULT_POINT_SIZE_get() {
 981   unsigned int jresult ;
 982   Dali::TextAbstraction::PointSize26Dot6 result;
 983
 984   result = (Dali::TextAbstraction::PointSize26Dot6)Dali::TextAbstraction::FontClient::DEFAULT_POINT_SIZE;
 985   jresult = result;
 986   return jresult;
 987 }
 988
 989
 990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FontClient_GlyphBufferData() {
 991   void * jresult ;
 992   Dali::TextAbstraction::FontClient::GlyphBufferData *result = 0 ;
 993
 994   {
 995     try {
 996       result = (Dali::TextAbstraction::FontClient::GlyphBufferData *)new Dali::TextAbstraction::FontClient::GlyphBufferData();
 997     } catch (std::out_of_range& e) {
 998       {
 999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1000       };
1001     } catch (std::exception& e) {
1002       {
1003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1004       };
1005     } catch (...) {
1006       {
1007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1008       };
1009     }
1010   }
1011   jresult = (void *)result;
1012   return jresult;
1013 }
1014
1015
1016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FontClient_GlyphBufferData(void * jarg1) {
1017   Dali::TextAbstraction::FontClient::GlyphBufferData *arg1 = (Dali::TextAbstraction::FontClient::GlyphBufferData *) 0 ;
1018
1019   arg1 = (Dali::TextAbstraction::FontClient::GlyphBufferData *)jarg1;
1020   {
1021     try {
1022       delete arg1;
1023     } catch (std::out_of_range& e) {
1024       {
1025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1026       };
1027     } catch (std::exception& e) {
1028       {
1029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1030       };
1031     } catch (...) {
1032       {
1033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1034       };
1035     }
1036   }
1037 }
1038
1039 /*
1040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontClient_GlyphBufferData_buffer_set(void * jarg1, unsigned char* jarg2) {
1041   Dali::TextAbstraction::FontClient::GlyphBufferData *arg1 = (Dali::TextAbstraction::FontClient::GlyphBufferData *) 0 ;
1042   unsigned char *arg2 = (unsigned char *) 0 ;
1043
1044   arg1 = (Dali::TextAbstraction::FontClient::GlyphBufferData *)jarg1;
1045   arg2 = jarg2;
1046   if (arg1) (arg1)->buffer = arg2;
1047
1048
1049 }
1050
1051
1052 SWIGEXPORT unsigned char* SWIGSTDCALL CSharp_Dali_FontClient_GlyphBufferData_buffer_get(void * jarg1) {
1053   unsigned char* jresult ;
1054   Dali::TextAbstraction::FontClient::GlyphBufferData *arg1 = (Dali::TextAbstraction::FontClient::GlyphBufferData *) 0 ;
1055   unsigned char *result = 0 ;
1056
1057   arg1 = (Dali::TextAbstraction::FontClient::GlyphBufferData *)jarg1;
1058   result = (unsigned char *) ((arg1)->buffer);
1059   jresult = (void *)result;
1060   return jresult;
1061 }
1062 */
1063
1064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontClient_GlyphBufferData_width_set(void * jarg1, unsigned int jarg2) {
1065   Dali::TextAbstraction::FontClient::GlyphBufferData *arg1 = (Dali::TextAbstraction::FontClient::GlyphBufferData *) 0 ;
1066   unsigned int arg2 ;
1067
1068   arg1 = (Dali::TextAbstraction::FontClient::GlyphBufferData *)jarg1;
1069   arg2 = (unsigned int)jarg2;
1070   if (arg1) (arg1)->width = arg2;
1071 }
1072
1073
1074 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_GlyphBufferData_width_get(void * jarg1) {
1075   unsigned int jresult ;
1076   Dali::TextAbstraction::FontClient::GlyphBufferData *arg1 = (Dali::TextAbstraction::FontClient::GlyphBufferData *) 0 ;
1077   unsigned int result;
1078
1079   arg1 = (Dali::TextAbstraction::FontClient::GlyphBufferData *)jarg1;
1080   result = (unsigned int) ((arg1)->width);
1081   jresult = result;
1082   return jresult;
1083 }
1084
1085
1086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontClient_GlyphBufferData_height_set(void * jarg1, unsigned int jarg2) {
1087   Dali::TextAbstraction::FontClient::GlyphBufferData *arg1 = (Dali::TextAbstraction::FontClient::GlyphBufferData *) 0 ;
1088   unsigned int arg2 ;
1089
1090   arg1 = (Dali::TextAbstraction::FontClient::GlyphBufferData *)jarg1;
1091   arg2 = (unsigned int)jarg2;
1092   if (arg1) (arg1)->height = arg2;
1093 }
1094
1095
1096 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_GlyphBufferData_height_get(void * jarg1) {
1097   unsigned int jresult ;
1098   Dali::TextAbstraction::FontClient::GlyphBufferData *arg1 = (Dali::TextAbstraction::FontClient::GlyphBufferData *) 0 ;
1099   unsigned int result;
1100
1101   arg1 = (Dali::TextAbstraction::FontClient::GlyphBufferData *)jarg1;
1102   result = (unsigned int) ((arg1)->height);
1103   jresult = result;
1104   return jresult;
1105 }
1106
1107
1108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontClient_GlyphBufferData_format_set(void * jarg1, int jarg2) {
1109   Dali::TextAbstraction::FontClient::GlyphBufferData *arg1 = (Dali::TextAbstraction::FontClient::GlyphBufferData *) 0 ;
1110   Dali::Pixel::Format arg2 ;
1111
1112   arg1 = (Dali::TextAbstraction::FontClient::GlyphBufferData *)jarg1;
1113   arg2 = (Dali::Pixel::Format)jarg2;
1114   if (arg1) (arg1)->format = arg2;
1115 }
1116
1117
1118 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FontClient_GlyphBufferData_format_get(void * jarg1) {
1119   int jresult ;
1120   Dali::TextAbstraction::FontClient::GlyphBufferData *arg1 = (Dali::TextAbstraction::FontClient::GlyphBufferData *) 0 ;
1121   Dali::Pixel::Format result;
1122
1123   arg1 = (Dali::TextAbstraction::FontClient::GlyphBufferData *)jarg1;
1124   result = (Dali::Pixel::Format) ((arg1)->format);
1125   jresult = (int)result;
1126   return jresult;
1127 }
1128
1129
1130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FontClient_Get() {
1131   void * jresult ;
1132   Dali::TextAbstraction::FontClient result;
1133
1134   {
1135     try {
1136       result = Dali::TextAbstraction::FontClient::Get();
1137     } catch (std::out_of_range& e) {
1138       {
1139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1140       };
1141     } catch (std::exception& e) {
1142       {
1143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1144       };
1145     } catch (...) {
1146       {
1147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1148       };
1149     }
1150   }
1151   jresult = new Dali::TextAbstraction::FontClient((const Dali::TextAbstraction::FontClient &)result);
1152   return jresult;
1153 }
1154
1155
1156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FontClient__SWIG_0() {
1157   void * jresult ;
1158   Dali::TextAbstraction::FontClient *result = 0 ;
1159
1160   {
1161     try {
1162       result = (Dali::TextAbstraction::FontClient *)new Dali::TextAbstraction::FontClient();
1163     } catch (std::out_of_range& e) {
1164       {
1165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1166       };
1167     } catch (std::exception& e) {
1168       {
1169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1170       };
1171     } catch (...) {
1172       {
1173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1174       };
1175     }
1176   }
1177   jresult = (void *)result;
1178   return jresult;
1179 }
1180
1181
1182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FontClient(void * jarg1) {
1183   Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ;
1184
1185   arg1 = (Dali::TextAbstraction::FontClient *)jarg1;
1186   {
1187     try {
1188       delete arg1;
1189     } catch (std::out_of_range& e) {
1190       {
1191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1192       };
1193     } catch (std::exception& e) {
1194       {
1195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1196       };
1197     } catch (...) {
1198       {
1199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1200       };
1201     }
1202   }
1203 }
1204
1205
1206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FontClient__SWIG_1(void * jarg1) {
1207   void * jresult ;
1208   Dali::TextAbstraction::FontClient *arg1 = 0 ;
1209   Dali::TextAbstraction::FontClient *result = 0 ;
1210
1211   arg1 = (Dali::TextAbstraction::FontClient *)jarg1;
1212   if (!arg1) {
1213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextAbstraction::FontClient const & type is null", 0);
1214     return 0;
1215   }
1216   {
1217     try {
1218       result = (Dali::TextAbstraction::FontClient *)new Dali::TextAbstraction::FontClient((Dali::TextAbstraction::FontClient const &)*arg1);
1219     } catch (std::out_of_range& e) {
1220       {
1221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1222       };
1223     } catch (std::exception& e) {
1224       {
1225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1226       };
1227     } catch (...) {
1228       {
1229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1230       };
1231     }
1232   }
1233   jresult = (void *)result;
1234   return jresult;
1235 }
1236
1237
1238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FontClient_Assign(void * jarg1, void * jarg2) {
1239   void * jresult ;
1240   Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ;
1241   Dali::TextAbstraction::FontClient *arg2 = 0 ;
1242   Dali::TextAbstraction::FontClient *result = 0 ;
1243
1244   arg1 = (Dali::TextAbstraction::FontClient *)jarg1;
1245   arg2 = (Dali::TextAbstraction::FontClient *)jarg2;
1246   if (!arg2) {
1247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextAbstraction::FontClient const & type is null", 0);
1248     return 0;
1249   }
1250   {
1251     try {
1252       result = (Dali::TextAbstraction::FontClient *) &(arg1)->operator =((Dali::TextAbstraction::FontClient const &)*arg2);
1253     } catch (std::out_of_range& e) {
1254       {
1255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1256       };
1257     } catch (std::exception& e) {
1258       {
1259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1260       };
1261     } catch (...) {
1262       {
1263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1264       };
1265     }
1266   }
1267   jresult = (void *)result;
1268   return jresult;
1269 }
1270
1271
1272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontClient_SetDpi(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
1273   Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ;
1274   unsigned int arg2 ;
1275   unsigned int arg3 ;
1276
1277   arg1 = (Dali::TextAbstraction::FontClient *)jarg1;
1278   arg2 = (unsigned int)jarg2;
1279   arg3 = (unsigned int)jarg3;
1280   {
1281     try {
1282       (arg1)->SetDpi(arg2,arg3);
1283     } catch (std::out_of_range& e) {
1284       {
1285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1286       };
1287     } catch (std::exception& e) {
1288       {
1289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1290       };
1291     } catch (...) {
1292       {
1293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1294       };
1295     }
1296   }
1297 }
1298
1299
1300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontClient_GetDpi(void * jarg1, void * jarg2, void * jarg3) {
1301   Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ;
1302   unsigned int *arg2 = 0 ;
1303   unsigned int *arg3 = 0 ;
1304
1305   arg1 = (Dali::TextAbstraction::FontClient *)jarg1;
1306   arg2 = (unsigned int *)jarg2;
1307   if (!arg2) {
1308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "unsigned int & type is null", 0);
1309     return ;
1310   }
1311   arg3 = (unsigned int *)jarg3;
1312   if (!arg3) {
1313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "unsigned int & type is null", 0);
1314     return ;
1315   }
1316   {
1317     try {
1318       (arg1)->GetDpi(*arg2,*arg3);
1319     } catch (std::out_of_range& e) {
1320       {
1321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1322       };
1323     } catch (std::exception& e) {
1324       {
1325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1326       };
1327     } catch (...) {
1328       {
1329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1330       };
1331     }
1332   }
1333 }
1334
1335
1336 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FontClient_GetDefaultFontSize(void * jarg1) {
1337   int jresult ;
1338   Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ;
1339   int result;
1340
1341   arg1 = (Dali::TextAbstraction::FontClient *)jarg1;
1342   {
1343     try {
1344       result = (int)(arg1)->GetDefaultFontSize();
1345     } catch (std::out_of_range& e) {
1346       {
1347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1348       };
1349     } catch (std::exception& e) {
1350       {
1351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1352       };
1353     } catch (...) {
1354       {
1355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1356       };
1357     }
1358   }
1359   jresult = result;
1360   return jresult;
1361 }
1362
1363
1364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontClient_ResetSystemDefaults(void * jarg1) {
1365   Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ;
1366
1367   arg1 = (Dali::TextAbstraction::FontClient *)jarg1;
1368   {
1369     try {
1370       (arg1)->ResetSystemDefaults();
1371     } catch (std::out_of_range& e) {
1372       {
1373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1374       };
1375     } catch (std::exception& e) {
1376       {
1377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1378       };
1379     } catch (...) {
1380       {
1381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1382       };
1383     }
1384   }
1385 }
1386
1387
1388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontClient_GetDefaultFonts(void * jarg1, void * jarg2) {
1389   Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ;
1390   Dali::TextAbstraction::FontList *arg2 = 0 ;
1391
1392   arg1 = (Dali::TextAbstraction::FontClient *)jarg1;
1393   arg2 = (Dali::TextAbstraction::FontList *)jarg2;
1394   if (!arg2) {
1395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextAbstraction::FontList & type is null", 0);
1396     return ;
1397   }
1398   {
1399     try {
1400       (arg1)->GetDefaultFonts(*arg2);
1401     } catch (std::out_of_range& e) {
1402       {
1403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1404       };
1405     } catch (std::exception& e) {
1406       {
1407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1408       };
1409     } catch (...) {
1410       {
1411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1412       };
1413     }
1414   }
1415 }
1416
1417
1418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontClient_GetDefaultPlatformFontDescription(void * jarg1, void * jarg2) {
1419   Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ;
1420   Dali::TextAbstraction::FontDescription *arg2 = 0 ;
1421
1422   arg1 = (Dali::TextAbstraction::FontClient *)jarg1;
1423   arg2 = (Dali::TextAbstraction::FontDescription *)jarg2;
1424   if (!arg2) {
1425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextAbstraction::FontDescription & type is null", 0);
1426     return ;
1427   }
1428   {
1429     try {
1430       (arg1)->GetDefaultPlatformFontDescription(*arg2);
1431     } catch (std::out_of_range& e) {
1432       {
1433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1434       };
1435     } catch (std::exception& e) {
1436       {
1437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1438       };
1439     } catch (...) {
1440       {
1441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1442       };
1443     }
1444   }
1445 }
1446
1447
1448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontClient_GetSystemFonts(void * jarg1, void * jarg2) {
1449   Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ;
1450   Dali::TextAbstraction::FontList *arg2 = 0 ;
1451
1452   arg1 = (Dali::TextAbstraction::FontClient *)jarg1;
1453   arg2 = (Dali::TextAbstraction::FontList *)jarg2;
1454   if (!arg2) {
1455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextAbstraction::FontList & type is null", 0);
1456     return ;
1457   }
1458   {
1459     try {
1460       (arg1)->GetSystemFonts(*arg2);
1461     } catch (std::out_of_range& e) {
1462       {
1463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1464       };
1465     } catch (std::exception& e) {
1466       {
1467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1468       };
1469     } catch (...) {
1470       {
1471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1472       };
1473     }
1474   }
1475 }
1476
1477
1478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontClient_GetDescription(void * jarg1, unsigned int jarg2, void * jarg3) {
1479   Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ;
1480   Dali::TextAbstraction::FontId arg2 ;
1481   Dali::TextAbstraction::FontDescription *arg3 = 0 ;
1482
1483   arg1 = (Dali::TextAbstraction::FontClient *)jarg1;
1484   arg2 = (Dali::TextAbstraction::FontId)jarg2;
1485   arg3 = (Dali::TextAbstraction::FontDescription *)jarg3;
1486   if (!arg3) {
1487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextAbstraction::FontDescription & type is null", 0);
1488     return ;
1489   }
1490   {
1491     try {
1492       (arg1)->GetDescription(arg2,*arg3);
1493     } catch (std::out_of_range& e) {
1494       {
1495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1496       };
1497     } catch (std::exception& e) {
1498       {
1499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1500       };
1501     } catch (...) {
1502       {
1503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1504       };
1505     }
1506   }
1507 }
1508
1509
1510 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_GetPointSize(void * jarg1, unsigned int jarg2) {
1511   unsigned int jresult ;
1512   Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ;
1513   Dali::TextAbstraction::FontId arg2 ;
1514   Dali::TextAbstraction::PointSize26Dot6 result;
1515
1516   arg1 = (Dali::TextAbstraction::FontClient *)jarg1;
1517   arg2 = (Dali::TextAbstraction::FontId)jarg2;
1518   {
1519     try {
1520       result = (arg1)->GetPointSize(arg2);
1521     } catch (std::out_of_range& e) {
1522       {
1523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1524       };
1525     } catch (std::exception& e) {
1526       {
1527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1528       };
1529     } catch (...) {
1530       {
1531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1532       };
1533     }
1534   }
1535   jresult = result;
1536   return jresult;
1537 }
1538
1539
1540 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_IsCharacterSupportedByFont(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
1541   unsigned int jresult ;
1542   Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ;
1543   Dali::TextAbstraction::FontId arg2 ;
1544   Dali::TextAbstraction::Character arg3 ;
1545   bool result;
1546
1547   arg1 = (Dali::TextAbstraction::FontClient *)jarg1;
1548   arg2 = (Dali::TextAbstraction::FontId)jarg2;
1549   arg3 = (Dali::TextAbstraction::Character)jarg3;
1550   {
1551     try {
1552       result = (bool)(arg1)->IsCharacterSupportedByFont(arg2,arg3);
1553     } catch (std::out_of_range& e) {
1554       {
1555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1556       };
1557     } catch (std::exception& e) {
1558       {
1559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1560       };
1561     } catch (...) {
1562       {
1563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1564       };
1565     }
1566   }
1567   jresult = result;
1568   return jresult;
1569 }
1570
1571
1572 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_FindDefaultFont__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
1573   unsigned int jresult ;
1574   Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ;
1575   Dali::TextAbstraction::Character arg2 ;
1576   Dali::TextAbstraction::PointSize26Dot6 arg3 ;
1577   bool arg4 ;
1578   Dali::TextAbstraction::FontId result;
1579
1580   arg1 = (Dali::TextAbstraction::FontClient *)jarg1;
1581   arg2 = (Dali::TextAbstraction::Character)jarg2;
1582   arg3 = (Dali::TextAbstraction::PointSize26Dot6)jarg3;
1583   arg4 = jarg4 ? true : false;
1584   {
1585     try {
1586       result = (arg1)->FindDefaultFont(arg2,arg3,arg4);
1587     } catch (std::out_of_range& e) {
1588       {
1589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1590       };
1591     } catch (std::exception& e) {
1592       {
1593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1594       };
1595     } catch (...) {
1596       {
1597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1598       };
1599     }
1600   }
1601   jresult = result;
1602   return jresult;
1603 }
1604
1605
1606 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_FindDefaultFont__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
1607   unsigned int jresult ;
1608   Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ;
1609   Dali::TextAbstraction::Character arg2 ;
1610   Dali::TextAbstraction::PointSize26Dot6 arg3 ;
1611   Dali::TextAbstraction::FontId result;
1612
1613   arg1 = (Dali::TextAbstraction::FontClient *)jarg1;
1614   arg2 = (Dali::TextAbstraction::Character)jarg2;
1615   arg3 = (Dali::TextAbstraction::PointSize26Dot6)jarg3;
1616   {
1617     try {
1618       result = (arg1)->FindDefaultFont(arg2,arg3);
1619     } catch (std::out_of_range& e) {
1620       {
1621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1622       };
1623     } catch (std::exception& e) {
1624       {
1625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1626       };
1627     } catch (...) {
1628       {
1629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1630       };
1631     }
1632   }
1633   jresult = result;
1634   return jresult;
1635 }
1636
1637
1638 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_FindDefaultFont__SWIG_2(void * jarg1, unsigned int jarg2) {
1639   unsigned int jresult ;
1640   Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ;
1641   Dali::TextAbstraction::Character arg2 ;
1642   Dali::TextAbstraction::FontId result;
1643
1644   arg1 = (Dali::TextAbstraction::FontClient *)jarg1;
1645   arg2 = (Dali::TextAbstraction::Character)jarg2;
1646   {
1647     try {
1648       result = (arg1)->FindDefaultFont(arg2);
1649     } catch (std::out_of_range& e) {
1650       {
1651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1652       };
1653     } catch (std::exception& e) {
1654       {
1655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1656       };
1657     } catch (...) {
1658       {
1659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1660       };
1661     }
1662   }
1663   jresult = result;
1664   return jresult;
1665 }
1666
1667
1668 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_FindFallbackFont__SWIG_0(void * jarg1, unsigned int jarg2, void * jarg3, unsigned int jarg4, unsigned int jarg5) {
1669   unsigned int jresult ;
1670   Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ;
1671   Dali::TextAbstraction::Character arg2 ;
1672   Dali::TextAbstraction::FontDescription *arg3 = 0 ;
1673   Dali::TextAbstraction::PointSize26Dot6 arg4 ;
1674   bool arg5 ;
1675   Dali::TextAbstraction::FontId result;
1676
1677   arg1 = (Dali::TextAbstraction::FontClient *)jarg1;
1678   arg2 = (Dali::TextAbstraction::Character)jarg2;
1679   arg3 = (Dali::TextAbstraction::FontDescription *)jarg3;
1680   if (!arg3) {
1681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextAbstraction::FontDescription const & type is null", 0);
1682     return 0;
1683   }
1684   arg4 = (Dali::TextAbstraction::PointSize26Dot6)jarg4;
1685   arg5 = jarg5 ? true : false;
1686   {
1687     try {
1688       result = (arg1)->FindFallbackFont(arg2,(Dali::TextAbstraction::FontDescription const &)*arg3,arg4,arg5);
1689     } catch (std::out_of_range& e) {
1690       {
1691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1692       };
1693     } catch (std::exception& e) {
1694       {
1695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1696       };
1697     } catch (...) {
1698       {
1699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1700       };
1701     }
1702   }
1703   jresult = result;
1704   return jresult;
1705 }
1706
1707
1708 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_FindFallbackFont__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3, unsigned int jarg4) {
1709   unsigned int jresult ;
1710   Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ;
1711   Dali::TextAbstraction::Character arg2 ;
1712   Dali::TextAbstraction::FontDescription *arg3 = 0 ;
1713   Dali::TextAbstraction::PointSize26Dot6 arg4 ;
1714   Dali::TextAbstraction::FontId result;
1715
1716   arg1 = (Dali::TextAbstraction::FontClient *)jarg1;
1717   arg2 = (Dali::TextAbstraction::Character)jarg2;
1718   arg3 = (Dali::TextAbstraction::FontDescription *)jarg3;
1719   if (!arg3) {
1720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextAbstraction::FontDescription const & type is null", 0);
1721     return 0;
1722   }
1723   arg4 = (Dali::TextAbstraction::PointSize26Dot6)jarg4;
1724   {
1725     try {
1726       result = (arg1)->FindFallbackFont(arg2,(Dali::TextAbstraction::FontDescription const &)*arg3,arg4);
1727     } catch (std::out_of_range& e) {
1728       {
1729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1730       };
1731     } catch (std::exception& e) {
1732       {
1733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1734       };
1735     } catch (...) {
1736       {
1737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1738       };
1739     }
1740   }
1741   jresult = result;
1742   return jresult;
1743 }
1744
1745
1746 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_FindFallbackFont__SWIG_2(void * jarg1, unsigned int jarg2, void * jarg3) {
1747   unsigned int jresult ;
1748   Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ;
1749   Dali::TextAbstraction::Character arg2 ;
1750   Dali::TextAbstraction::FontDescription *arg3 = 0 ;
1751   Dali::TextAbstraction::FontId result;
1752
1753   arg1 = (Dali::TextAbstraction::FontClient *)jarg1;
1754   arg2 = (Dali::TextAbstraction::Character)jarg2;
1755   arg3 = (Dali::TextAbstraction::FontDescription *)jarg3;
1756   if (!arg3) {
1757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextAbstraction::FontDescription const & type is null", 0);
1758     return 0;
1759   }
1760   {
1761     try {
1762       result = (arg1)->FindFallbackFont(arg2,(Dali::TextAbstraction::FontDescription const &)*arg3);
1763     } catch (std::out_of_range& e) {
1764       {
1765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1766       };
1767     } catch (std::exception& e) {
1768       {
1769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1770       };
1771     } catch (...) {
1772       {
1773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1774       };
1775     }
1776   }
1777   jresult = result;
1778   return jresult;
1779 }
1780
1781
1782 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_GetFontId__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3, unsigned int jarg4) {
1783   unsigned int jresult ;
1784   Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ;
1785   Dali::TextAbstraction::FontPath *arg2 = 0 ;
1786   Dali::TextAbstraction::PointSize26Dot6 arg3 ;
1787   Dali::TextAbstraction::FaceIndex arg4 ;
1788   Dali::TextAbstraction::FontId result;
1789
1790   arg1 = (Dali::TextAbstraction::FontClient *)jarg1;
1791   if (!jarg2) {
1792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
1793     return 0;
1794   }
1795   Dali::TextAbstraction::FontPath arg2_str(jarg2);
1796   arg2 = &arg2_str;
1797   arg3 = (Dali::TextAbstraction::PointSize26Dot6)jarg3;
1798   arg4 = (Dali::TextAbstraction::FaceIndex)jarg4;
1799   {
1800     try {
1801       result = (arg1)->GetFontId((Dali::TextAbstraction::FontPath const &)*arg2,arg3,arg4);
1802     } catch (std::out_of_range& e) {
1803       {
1804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1805       };
1806     } catch (std::exception& e) {
1807       {
1808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1809       };
1810     } catch (...) {
1811       {
1812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1813       };
1814     }
1815   }
1816   jresult = result;
1817   return jresult;
1818 }
1819
1820
1821 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_GetFontId__SWIG_1(void * jarg1, char * jarg2, unsigned int jarg3) {
1822   unsigned int jresult ;
1823   Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ;
1824   Dali::TextAbstraction::FontPath *arg2 = 0 ;
1825   Dali::TextAbstraction::PointSize26Dot6 arg3 ;
1826   Dali::TextAbstraction::FontId result;
1827
1828   arg1 = (Dali::TextAbstraction::FontClient *)jarg1;
1829   if (!jarg2) {
1830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
1831     return 0;
1832   }
1833   Dali::TextAbstraction::FontPath arg2_str(jarg2);
1834   arg2 = &arg2_str;
1835   arg3 = (Dali::TextAbstraction::PointSize26Dot6)jarg3;
1836   {
1837     try {
1838       result = (arg1)->GetFontId((Dali::TextAbstraction::FontPath const &)*arg2,arg3);
1839     } catch (std::out_of_range& e) {
1840       {
1841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1842       };
1843     } catch (std::exception& e) {
1844       {
1845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1846       };
1847     } catch (...) {
1848       {
1849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1850       };
1851     }
1852   }
1853   jresult = result;
1854   return jresult;
1855 }
1856
1857
1858 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_GetFontId__SWIG_2(void * jarg1, char * jarg2) {
1859   unsigned int jresult ;
1860   Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ;
1861   Dali::TextAbstraction::FontPath *arg2 = 0 ;
1862   Dali::TextAbstraction::FontId result;
1863
1864   arg1 = (Dali::TextAbstraction::FontClient *)jarg1;
1865   if (!jarg2) {
1866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
1867     return 0;
1868   }
1869   Dali::TextAbstraction::FontPath arg2_str(jarg2);
1870   arg2 = &arg2_str;
1871   {
1872     try {
1873       result = (arg1)->GetFontId((Dali::TextAbstraction::FontPath const &)*arg2);
1874     } catch (std::out_of_range& e) {
1875       {
1876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1877       };
1878     } catch (std::exception& e) {
1879       {
1880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1881       };
1882     } catch (...) {
1883       {
1884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1885       };
1886     }
1887   }
1888   jresult = result;
1889   return jresult;
1890 }
1891
1892
1893 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_GetFontId__SWIG_3(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
1894   unsigned int jresult ;
1895   Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ;
1896   Dali::TextAbstraction::FontDescription *arg2 = 0 ;
1897   Dali::TextAbstraction::PointSize26Dot6 arg3 ;
1898   Dali::TextAbstraction::FaceIndex arg4 ;
1899   Dali::TextAbstraction::FontId result;
1900
1901   arg1 = (Dali::TextAbstraction::FontClient *)jarg1;
1902   arg2 = (Dali::TextAbstraction::FontDescription *)jarg2;
1903   if (!arg2) {
1904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextAbstraction::FontDescription const & type is null", 0);
1905     return 0;
1906   }
1907   arg3 = (Dali::TextAbstraction::PointSize26Dot6)jarg3;
1908   arg4 = (Dali::TextAbstraction::FaceIndex)jarg4;
1909   {
1910     try {
1911       result = (arg1)->GetFontId((Dali::TextAbstraction::FontDescription const &)*arg2,arg3,arg4);
1912     } catch (std::out_of_range& e) {
1913       {
1914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1915       };
1916     } catch (std::exception& e) {
1917       {
1918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1919       };
1920     } catch (...) {
1921       {
1922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1923       };
1924     }
1925   }
1926   jresult = result;
1927   return jresult;
1928 }
1929
1930
1931 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_GetFontId__SWIG_4(void * jarg1, void * jarg2, unsigned int jarg3) {
1932   unsigned int jresult ;
1933   Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ;
1934   Dali::TextAbstraction::FontDescription *arg2 = 0 ;
1935   Dali::TextAbstraction::PointSize26Dot6 arg3 ;
1936   Dali::TextAbstraction::FontId result;
1937
1938   arg1 = (Dali::TextAbstraction::FontClient *)jarg1;
1939   arg2 = (Dali::TextAbstraction::FontDescription *)jarg2;
1940   if (!arg2) {
1941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextAbstraction::FontDescription const & type is null", 0);
1942     return 0;
1943   }
1944   arg3 = (Dali::TextAbstraction::PointSize26Dot6)jarg3;
1945   {
1946     try {
1947       result = (arg1)->GetFontId((Dali::TextAbstraction::FontDescription const &)*arg2,arg3);
1948     } catch (std::out_of_range& e) {
1949       {
1950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1951       };
1952     } catch (std::exception& e) {
1953       {
1954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1955       };
1956     } catch (...) {
1957       {
1958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1959       };
1960     }
1961   }
1962   jresult = result;
1963   return jresult;
1964 }
1965
1966
1967 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_GetFontId__SWIG_5(void * jarg1, void * jarg2) {
1968   unsigned int jresult ;
1969   Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ;
1970   Dali::TextAbstraction::FontDescription *arg2 = 0 ;
1971   Dali::TextAbstraction::FontId result;
1972
1973   arg1 = (Dali::TextAbstraction::FontClient *)jarg1;
1974   arg2 = (Dali::TextAbstraction::FontDescription *)jarg2;
1975   if (!arg2) {
1976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextAbstraction::FontDescription const & type is null", 0);
1977     return 0;
1978   }
1979   {
1980     try {
1981       result = (arg1)->GetFontId((Dali::TextAbstraction::FontDescription const &)*arg2);
1982     } catch (std::out_of_range& e) {
1983       {
1984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1985       };
1986     } catch (std::exception& e) {
1987       {
1988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1989       };
1990     } catch (...) {
1991       {
1992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1993       };
1994     }
1995   }
1996   jresult = result;
1997   return jresult;
1998 }
1999
2000
2001 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_IsScalable__SWIG_0(void * jarg1, char * jarg2) {
2002   unsigned int jresult ;
2003   Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ;
2004   Dali::TextAbstraction::FontPath *arg2 = 0 ;
2005   bool result;
2006
2007   arg1 = (Dali::TextAbstraction::FontClient *)jarg1;
2008   if (!jarg2) {
2009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
2010     return 0;
2011   }
2012   Dali::TextAbstraction::FontPath arg2_str(jarg2);
2013   arg2 = &arg2_str;
2014   {
2015     try {
2016       result = (bool)(arg1)->IsScalable((Dali::TextAbstraction::FontPath const &)*arg2);
2017     } catch (std::out_of_range& e) {
2018       {
2019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2020       };
2021     } catch (std::exception& e) {
2022       {
2023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2024       };
2025     } catch (...) {
2026       {
2027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2028       };
2029     }
2030   }
2031   jresult = result;
2032   return jresult;
2033 }
2034
2035
2036 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_IsScalable__SWIG_1(void * jarg1, void * jarg2) {
2037   unsigned int jresult ;
2038   Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ;
2039   Dali::TextAbstraction::FontDescription *arg2 = 0 ;
2040   bool result;
2041
2042   arg1 = (Dali::TextAbstraction::FontClient *)jarg1;
2043   arg2 = (Dali::TextAbstraction::FontDescription *)jarg2;
2044   if (!arg2) {
2045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextAbstraction::FontDescription const & type is null", 0);
2046     return 0;
2047   }
2048   {
2049     try {
2050       result = (bool)(arg1)->IsScalable((Dali::TextAbstraction::FontDescription const &)*arg2);
2051     } catch (std::out_of_range& e) {
2052       {
2053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2054       };
2055     } catch (std::exception& e) {
2056       {
2057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2058       };
2059     } catch (...) {
2060       {
2061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2062       };
2063     }
2064   }
2065   jresult = result;
2066   return jresult;
2067 }
2068
2069
2070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontClient_GetFixedSizes__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
2071   Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ;
2072   Dali::TextAbstraction::FontPath *arg2 = 0 ;
2073   Dali::Vector< Dali::TextAbstraction::PointSize26Dot6,Dali::TypeTraits< Dali::TextAbstraction::PointSize26Dot6 >::IS_TRIVIAL_TYPE==true > *arg3 = 0 ;
2074
2075   arg1 = (Dali::TextAbstraction::FontClient *)jarg1;
2076   if (!jarg2) {
2077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
2078     return ;
2079   }
2080   Dali::TextAbstraction::FontPath arg2_str(jarg2);
2081   arg2 = &arg2_str;
2082   arg3 = (Dali::Vector< Dali::TextAbstraction::PointSize26Dot6,Dali::TypeTraits< Dali::TextAbstraction::PointSize26Dot6 >::IS_TRIVIAL_TYPE==true > *)jarg3;
2083   if (!arg3) {
2084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::TextAbstraction::PointSize26Dot6,Dali::TypeTraits< Dali::TextAbstraction::PointSize26Dot6 >::IS_TRIVIAL_TYPE==true > & type is null", 0);
2085     return ;
2086   }
2087   {
2088     try {
2089       (arg1)->GetFixedSizes((Dali::TextAbstraction::FontPath const &)*arg2,*arg3);
2090     } catch (std::out_of_range& e) {
2091       {
2092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2093       };
2094     } catch (std::exception& e) {
2095       {
2096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2097       };
2098     } catch (...) {
2099       {
2100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2101       };
2102     }
2103   }
2104 }
2105
2106
2107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontClient_GetFixedSizes__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
2108   Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ;
2109   Dali::TextAbstraction::FontDescription *arg2 = 0 ;
2110   Dali::Vector< Dali::TextAbstraction::PointSize26Dot6,Dali::TypeTraits< Dali::TextAbstraction::PointSize26Dot6 >::IS_TRIVIAL_TYPE==true > *arg3 = 0 ;
2111
2112   arg1 = (Dali::TextAbstraction::FontClient *)jarg1;
2113   arg2 = (Dali::TextAbstraction::FontDescription *)jarg2;
2114   if (!arg2) {
2115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextAbstraction::FontDescription const & type is null", 0);
2116     return ;
2117   }
2118   arg3 = (Dali::Vector< Dali::TextAbstraction::PointSize26Dot6,Dali::TypeTraits< Dali::TextAbstraction::PointSize26Dot6 >::IS_TRIVIAL_TYPE==true > *)jarg3;
2119   if (!arg3) {
2120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::TextAbstraction::PointSize26Dot6,Dali::TypeTraits< Dali::TextAbstraction::PointSize26Dot6 >::IS_TRIVIAL_TYPE==true > & type is null", 0);
2121     return ;
2122   }
2123   {
2124     try {
2125       (arg1)->GetFixedSizes((Dali::TextAbstraction::FontDescription const &)*arg2,*arg3);
2126     } catch (std::out_of_range& e) {
2127       {
2128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2129       };
2130     } catch (std::exception& e) {
2131       {
2132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2133       };
2134     } catch (...) {
2135       {
2136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2137       };
2138     }
2139   }
2140 }
2141
2142
2143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontClient_GetFontMetrics(void * jarg1, unsigned int jarg2, void * jarg3) {
2144   Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ;
2145   Dali::TextAbstraction::FontId arg2 ;
2146   Dali::TextAbstraction::FontMetrics *arg3 = 0 ;
2147
2148   arg1 = (Dali::TextAbstraction::FontClient *)jarg1;
2149   arg2 = (Dali::TextAbstraction::FontId)jarg2;
2150   arg3 = (Dali::TextAbstraction::FontMetrics *)jarg3;
2151   if (!arg3) {
2152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextAbstraction::FontMetrics & type is null", 0);
2153     return ;
2154   }
2155   {
2156     try {
2157       (arg1)->GetFontMetrics(arg2,*arg3);
2158     } catch (std::out_of_range& e) {
2159       {
2160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2161       };
2162     } catch (std::exception& e) {
2163       {
2164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2165       };
2166     } catch (...) {
2167       {
2168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2169       };
2170     }
2171   }
2172 }
2173
2174
2175 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_GetGlyphIndex(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
2176   unsigned int jresult ;
2177   Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ;
2178   Dali::TextAbstraction::FontId arg2 ;
2179   Dali::TextAbstraction::Character arg3 ;
2180   Dali::TextAbstraction::GlyphIndex result;
2181
2182   arg1 = (Dali::TextAbstraction::FontClient *)jarg1;
2183   arg2 = (Dali::TextAbstraction::FontId)jarg2;
2184   arg3 = (Dali::TextAbstraction::Character)jarg3;
2185   {
2186     try {
2187       result = (arg1)->GetGlyphIndex(arg2,arg3);
2188     } catch (std::out_of_range& e) {
2189       {
2190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2191       };
2192     } catch (std::exception& e) {
2193       {
2194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2195       };
2196     } catch (...) {
2197       {
2198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2199       };
2200     }
2201   }
2202   jresult = result;
2203   return jresult;
2204 }
2205
2206
2207 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_GetGlyphMetrics__SWIG_0(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
2208   unsigned int jresult ;
2209   Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ;
2210   Dali::TextAbstraction::GlyphInfo *arg2 = (Dali::TextAbstraction::GlyphInfo *) 0 ;
2211   uint32_t arg3 ;
2212   Dali::TextAbstraction::GlyphType arg4 ;
2213   bool arg5 ;
2214   bool result;
2215
2216   arg1 = (Dali::TextAbstraction::FontClient *)jarg1;
2217   arg2 = (Dali::TextAbstraction::GlyphInfo *)jarg2;
2218   arg3 = (uint32_t)jarg3;
2219   arg4 = (Dali::TextAbstraction::GlyphType)jarg4;
2220   arg5 = jarg5 ? true : false;
2221   {
2222     try {
2223       result = (bool)(arg1)->GetGlyphMetrics(arg2,arg3,arg4,arg5);
2224     } catch (std::out_of_range& e) {
2225       {
2226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2227       };
2228     } catch (std::exception& e) {
2229       {
2230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2231       };
2232     } catch (...) {
2233       {
2234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2235       };
2236     }
2237   }
2238   jresult = result;
2239   return jresult;
2240 }
2241
2242
2243 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_GetGlyphMetrics__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
2244   unsigned int jresult ;
2245   Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ;
2246   Dali::TextAbstraction::GlyphInfo *arg2 = (Dali::TextAbstraction::GlyphInfo *) 0 ;
2247   uint32_t arg3 ;
2248   Dali::TextAbstraction::GlyphType arg4 ;
2249   bool result;
2250
2251   arg1 = (Dali::TextAbstraction::FontClient *)jarg1;
2252   arg2 = (Dali::TextAbstraction::GlyphInfo *)jarg2;
2253   arg3 = (uint32_t)jarg3;
2254   arg4 = (Dali::TextAbstraction::GlyphType)jarg4;
2255   {
2256     try {
2257       result = (bool)(arg1)->GetGlyphMetrics(arg2,arg3,arg4);
2258     } catch (std::out_of_range& e) {
2259       {
2260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2261       };
2262     } catch (std::exception& e) {
2263       {
2264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2265       };
2266     } catch (...) {
2267       {
2268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2269       };
2270     }
2271   }
2272   jresult = result;
2273   return jresult;
2274 }
2275
2276
2277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontClient_CreateBitmap__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3, bool jarg4, bool jarg5, void * jarg6, int jarg7) {
2278   Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ;
2279   Dali::TextAbstraction::FontId arg2 ;
2280   Dali::TextAbstraction::GlyphIndex arg3 ;
2281   bool arg4;
2282   bool arg5;
2283   Dali::TextAbstraction::FontClient::GlyphBufferData *arg6 = 0 ;
2284   int arg7 ;
2285
2286   arg1 = (Dali::TextAbstraction::FontClient *)jarg1;
2287   arg2 = (Dali::TextAbstraction::FontId)jarg2;
2288   arg3 = (Dali::TextAbstraction::GlyphIndex)jarg3;
2289   arg4 = jarg4;
2290   arg5 = jarg5;
2291   arg6 = (Dali::TextAbstraction::FontClient::GlyphBufferData *)jarg6;
2292   if (!arg6) {
2293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextAbstraction::FontClient::GlyphBufferData & type is null", 0);
2294     return ;
2295   }
2296   arg7 = (int)jarg7;
2297   {
2298     try {
2299       (arg1)->CreateBitmap(arg2,arg3,arg4,arg5,*arg6,arg7);
2300     } catch (std::out_of_range& e) {
2301       {
2302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2303       };
2304     } catch (std::exception& e) {
2305       {
2306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2307       };
2308     } catch (...) {
2309       {
2310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2311       };
2312     }
2313   }
2314 }
2315
2316
2317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FontClient_CreateBitmap__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
2318   void * jresult ;
2319   Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ;
2320   Dali::TextAbstraction::FontId arg2 ;
2321   Dali::TextAbstraction::GlyphIndex arg3 ;
2322   int arg4 ;
2323   Dali::PixelData result;
2324
2325   arg1 = (Dali::TextAbstraction::FontClient *)jarg1;
2326   arg2 = (Dali::TextAbstraction::FontId)jarg2;
2327   arg3 = (Dali::TextAbstraction::GlyphIndex)jarg3;
2328   arg4 = (int)jarg4;
2329   {
2330     try {
2331       result = (arg1)->CreateBitmap(arg2,arg3,arg4);
2332     } catch (std::out_of_range& e) {
2333       {
2334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2335       };
2336     } catch (std::exception& e) {
2337       {
2338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2339       };
2340     } catch (...) {
2341       {
2342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2343       };
2344     }
2345   }
2346   jresult = new Dali::PixelData((const Dali::PixelData &)result);
2347   return jresult;
2348 }
2349
2350
2351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontClient_CreateVectorBlob(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7) {
2352   Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ;
2353   Dali::TextAbstraction::FontId arg2 ;
2354   Dali::TextAbstraction::GlyphIndex arg3 ;
2355   Dali::TextAbstraction::VectorBlob **arg4 = 0 ;
2356   unsigned int *arg5 = 0 ;
2357   unsigned int *arg6 = 0 ;
2358   unsigned int *arg7 = 0 ;
2359
2360   arg1 = (Dali::TextAbstraction::FontClient *)jarg1;
2361   arg2 = (Dali::TextAbstraction::FontId)jarg2;
2362   arg3 = (Dali::TextAbstraction::GlyphIndex)jarg3;
2363   arg4 = (Dali::TextAbstraction::VectorBlob **)jarg4;
2364   if (!arg4) {
2365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextAbstraction::VectorBlob *& type is null", 0);
2366     return ;
2367   }
2368   arg5 = (unsigned int *)jarg5;
2369   if (!arg5) {
2370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "unsigned int & type is null", 0);
2371     return ;
2372   }
2373   arg6 = (unsigned int *)jarg6;
2374   if (!arg6) {
2375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "unsigned int & type is null", 0);
2376     return ;
2377   }
2378   arg7 = (unsigned int *)jarg7;
2379   if (!arg7) {
2380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "unsigned int & type is null", 0);
2381     return ;
2382   }
2383   {
2384     try {
2385       (arg1)->CreateVectorBlob(arg2,arg3,*arg4,*arg5,*arg6,*arg7);
2386     } catch (std::out_of_range& e) {
2387       {
2388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2389       };
2390     } catch (std::exception& e) {
2391       {
2392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2393       };
2394     } catch (...) {
2395       {
2396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2397       };
2398     }
2399   }
2400 }
2401
2402
2403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FontClient_GetEllipsisGlyph(void * jarg1, unsigned int jarg2) {
2404   void * jresult ;
2405   Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ;
2406   Dali::TextAbstraction::PointSize26Dot6 arg2 ;
2407   Dali::TextAbstraction::GlyphInfo *result = 0 ;
2408
2409   arg1 = (Dali::TextAbstraction::FontClient *)jarg1;
2410   arg2 = (Dali::TextAbstraction::PointSize26Dot6)jarg2;
2411   {
2412     try {
2413       result = (Dali::TextAbstraction::GlyphInfo *) &(arg1)->GetEllipsisGlyph(arg2);
2414     } catch (std::out_of_range& e) {
2415       {
2416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2417       };
2418     } catch (std::exception& e) {
2419       {
2420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2421       };
2422     } catch (...) {
2423       {
2424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2425       };
2426     }
2427   }
2428   jresult = (void *)result;
2429   return jresult;
2430 }
2431
2432
2433 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_IsColorGlyph(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
2434   unsigned int jresult ;
2435   Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ;
2436   Dali::TextAbstraction::FontId arg2 ;
2437   Dali::TextAbstraction::GlyphIndex arg3 ;
2438   bool result;
2439
2440   arg1 = (Dali::TextAbstraction::FontClient *)jarg1;
2441   arg2 = (Dali::TextAbstraction::FontId)jarg2;
2442   arg3 = (Dali::TextAbstraction::GlyphIndex)jarg3;
2443   {
2444     try {
2445       result = (bool)(arg1)->IsColorGlyph(arg2,arg3);
2446     } catch (std::out_of_range& e) {
2447       {
2448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2449       };
2450     } catch (std::exception& e) {
2451       {
2452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2453       };
2454     } catch (...) {
2455       {
2456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2457       };
2458     }
2459   }
2460   jresult = result;
2461   return jresult;
2462 }
2463
2464
2465 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_AddCustomFontDirectory(void * jarg1, char * jarg2) {
2466   unsigned int jresult ;
2467   Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ;
2468   Dali::TextAbstraction::FontPath *arg2 = 0 ;
2469   bool result;
2470
2471   arg1 = (Dali::TextAbstraction::FontClient *)jarg1;
2472   if (!jarg2) {
2473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
2474     return 0;
2475   }
2476   Dali::TextAbstraction::FontPath arg2_str(jarg2);
2477   arg2 = &arg2_str;
2478   {
2479     try {
2480       result = (bool)(arg1)->AddCustomFontDirectory((Dali::TextAbstraction::FontPath const &)*arg2);
2481     } catch (std::out_of_range& e) {
2482       {
2483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2484       };
2485     } catch (std::exception& e) {
2486       {
2487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2488       };
2489     } catch (...) {
2490       {
2491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2492       };
2493     }
2494   }
2495   jresult = result;
2496   return jresult;
2497 }
2498
2499 #ifdef __cplusplus
2500 }
2501 #endif
2502