src/Tizen.NUI/src/public/BaseComponents/TextLabel.cs

   1 /*
   2  * Copyright(c) 2019 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 extern alias TizenSystemSettings;
  19 using TizenSystemSettings.Tizen.System;
  20 using System;
  21 using System.Globalization;
  22 using System.ComponentModel;
  23 using Tizen.NUI.Binding;
  24
  25 namespace Tizen.NUI.BaseComponents
  26 {
  27
  28     /// <summary>
  29     /// A control which renders a short text string.<br />
  30     /// Text labels are lightweight, non-editable, and do not respond to the user input.<br />
  31     /// </summary>
  32     /// <since_tizen> 3 </since_tizen>
  33     public class TextLabel : View
  34     {
  35         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
  36         [EditorBrowsable(EditorBrowsableState.Never)]
  37         public static readonly BindableProperty TextProperty = BindableProperty.Create(nameof(Text), typeof(string), typeof(TextLabel), string.Empty, propertyChanged: (bindable, oldValue, newValue) =>
  38         {
  39             var textLabel = (TextLabel)bindable;
  40             if (newValue != null)
  41             {
  42                 Tizen.NUI.Object.SetProperty(textLabel.swigCPtr, TextLabel.Property.TEXT, new Tizen.NUI.PropertyValue((string)newValue));
  43             }
  44         },
  45         defaultValueCreator: (bindable) =>
  46         {
  47             var textLabel = (TextLabel)bindable;
  48             string temp;
  49             Tizen.NUI.Object.GetProperty(textLabel.swigCPtr, TextLabel.Property.TEXT).Get(out temp);
  50             return temp;
  51         });
  52         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
  53         [EditorBrowsable(EditorBrowsableState.Never)]
  54         public static readonly BindableProperty FontFamilyProperty = BindableProperty.Create(nameof(FontFamily), typeof(string), typeof(TextLabel), string.Empty, propertyChanged: (bindable, oldValue, newValue) =>
  55         {
  56             var textLabel = (TextLabel)bindable;
  57             if (newValue != null)
  58             {
  59                 Tizen.NUI.Object.SetProperty(textLabel.swigCPtr, TextLabel.Property.FONT_FAMILY, new Tizen.NUI.PropertyValue((string)newValue));
  60             }
  61         },
  62         defaultValueCreator: (bindable) =>
  63         {
  64             var textLabel = (TextLabel)bindable;
  65             string temp;
  66             Tizen.NUI.Object.GetProperty(textLabel.swigCPtr, TextLabel.Property.FONT_FAMILY).Get(out temp);
  67             return temp;
  68         });
  69         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
  70         [EditorBrowsable(EditorBrowsableState.Never)]
  71         public static readonly BindableProperty FontStyleProperty = BindableProperty.Create(nameof(FontStyle), typeof(PropertyMap), typeof(TextLabel), null, propertyChanged: (bindable, oldValue, newValue) =>
  72         {
  73             var textLabel = (TextLabel)bindable;
  74             if (newValue != null)
  75             {
  76                 Tizen.NUI.Object.SetProperty(textLabel.swigCPtr, TextLabel.Property.FONT_STYLE, new Tizen.NUI.PropertyValue((PropertyMap)newValue));
  77             }
  78         },
  79         defaultValueCreator: (bindable) =>
  80         {
  81             var textLabel = (TextLabel)bindable;
  82             PropertyMap temp = new PropertyMap();
  83             Tizen.NUI.Object.GetProperty(textLabel.swigCPtr, TextLabel.Property.FONT_STYLE).Get(temp);
  84             return temp;
  85         });
  86         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
  87         [EditorBrowsable(EditorBrowsableState.Never)]
  88         public static readonly BindableProperty PointSizeProperty = BindableProperty.Create(nameof(PointSize), typeof(float), typeof(TextLabel), default(float), propertyChanged: (bindable, oldValue, newValue) =>
  89         {
  90             var textLabel = (TextLabel)bindable;
  91             if (newValue != null)
  92             {
  93                 Tizen.NUI.Object.SetProperty(textLabel.swigCPtr, TextLabel.Property.POINT_SIZE, new Tizen.NUI.PropertyValue((float)newValue));
  94             }
  95         },
  96         defaultValueCreator: (bindable) =>
  97         {
  98             var textLabel = (TextLabel)bindable;
  99             float temp = 0.0f;
 100             Tizen.NUI.Object.GetProperty(textLabel.swigCPtr, TextLabel.Property.POINT_SIZE).Get(out temp);
 101             return temp;
 102         });
 103         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 104         [EditorBrowsable(EditorBrowsableState.Never)]
 105         public static readonly BindableProperty MultiLineProperty = BindableProperty.Create(nameof(MultiLine), typeof(bool), typeof(TextLabel), false, propertyChanged: (bindable, oldValue, newValue) =>
 106         {
 107             var textLabel = (TextLabel)bindable;
 108             if (newValue != null)
 109             {
 110                 Tizen.NUI.Object.SetProperty(textLabel.swigCPtr, TextLabel.Property.MULTI_LINE, new Tizen.NUI.PropertyValue((bool)newValue));
 111             }
 112         },
 113         defaultValueCreator: (bindable) =>
 114         {
 115             var textLabel = (TextLabel)bindable;
 116             bool temp = false;
 117             Tizen.NUI.Object.GetProperty(textLabel.swigCPtr, TextLabel.Property.MULTI_LINE).Get(out temp);
 118             return temp;
 119         });
 120         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 121         [EditorBrowsable(EditorBrowsableState.Never)]
 122         public static readonly BindableProperty HorizontalAlignmentProperty = BindableProperty.Create(nameof(HorizontalAlignment), typeof(HorizontalAlignment), typeof(TextLabel), HorizontalAlignment.Begin, propertyChanged: (bindable, oldValue, newValue) =>
 123         {
 124             var textLabel = (TextLabel)bindable;
 125             string valueToString = "";
 126             if (newValue != null)
 127             {
 128                 switch ((HorizontalAlignment)newValue)
 129                 {
 130                     case HorizontalAlignment.Begin: { valueToString = "BEGIN"; break; }
 131                     case HorizontalAlignment.Center: { valueToString = "CENTER"; break; }
 132                     case HorizontalAlignment.End: { valueToString = "END"; break; }
 133                     default: { valueToString = "BEGIN"; break; }
 134                 }
 135                 Tizen.NUI.Object.SetProperty(textLabel.swigCPtr, TextLabel.Property.HORIZONTAL_ALIGNMENT, new Tizen.NUI.PropertyValue(valueToString));
 136             }
 137         },
 138         defaultValueCreator: (bindable) =>
 139         {
 140             var textLabel = (TextLabel)bindable;
 141             string temp;
 142             if (Tizen.NUI.Object.GetProperty(textLabel.swigCPtr, TextLabel.Property.HORIZONTAL_ALIGNMENT).Get(out temp) == false)
 143             {
 144                 NUILog.Error("HorizontalAlignment get error!");
 145             }
 146             switch (temp)
 147             {
 148                 case "BEGIN": return HorizontalAlignment.Begin;
 149                 case "CENTER": return HorizontalAlignment.Center;
 150                 case "END": return HorizontalAlignment.End;
 151                 default: return HorizontalAlignment.Begin;
 152             }
 153         });
 154         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 155         [EditorBrowsable(EditorBrowsableState.Never)]
 156         public static readonly BindableProperty VerticalAlignmentProperty = BindableProperty.Create(nameof(VerticalAlignment), typeof(VerticalAlignment), typeof(TextLabel), VerticalAlignment.Bottom, propertyChanged: (bindable, oldValue, newValue) =>
 157         {
 158             var textLabel = (TextLabel)bindable;
 159             string valueToString = "";
 160             if (newValue != null)
 161             {
 162                 switch ((VerticalAlignment)newValue)
 163                 {
 164                     case VerticalAlignment.Top: { valueToString = "TOP"; break; }
 165                     case VerticalAlignment.Center: { valueToString = "CENTER"; break; }
 166                     case VerticalAlignment.Bottom: { valueToString = "BOTTOM"; break; }
 167                     default: { valueToString = "BOTTOM"; break; }
 168                 }
 169                 Tizen.NUI.Object.SetProperty(textLabel.swigCPtr, TextLabel.Property.VERTICAL_ALIGNMENT, new Tizen.NUI.PropertyValue(valueToString));
 170             }
 171         },
 172         defaultValueCreator: (bindable) =>
 173         {
 174             var textLabel = (TextLabel)bindable;
 175             string temp;
 176             if (Tizen.NUI.Object.GetProperty(textLabel.swigCPtr, TextLabel.Property.VERTICAL_ALIGNMENT).Get(out temp) == false)
 177             {
 178                 NUILog.Error("VerticalAlignment get error!");
 179             }
 180
 181             switch (temp)
 182             {
 183                 case "TOP": return VerticalAlignment.Top;
 184                 case "CENTER": return VerticalAlignment.Center;
 185                 case "BOTTOM": return VerticalAlignment.Bottom;
 186                 default: return VerticalAlignment.Bottom;
 187             }
 188         });
 189         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 190         [EditorBrowsable(EditorBrowsableState.Never)]
 191         public static readonly BindableProperty TextColorProperty = BindableProperty.Create(nameof(TextColor), typeof(Color), typeof(TextLabel), null, propertyChanged: (bindable, oldValue, newValue) =>
 192         {
 193             var textLabel = (TextLabel)bindable;
 194             if (newValue != null)
 195             {
 196                 Tizen.NUI.Object.SetProperty(textLabel.swigCPtr, TextLabel.Property.TEXT_COLOR, new Tizen.NUI.PropertyValue((Color)newValue));
 197             }
 198         },
 199         defaultValueCreator: (bindable) =>
 200         {
 201             var textLabel = (TextLabel)bindable;
 202             Color temp = new Color(0.0f, 0.0f, 0.0f, 0.0f);
 203             Tizen.NUI.Object.GetProperty(textLabel.swigCPtr, TextLabel.Property.TEXT_COLOR).Get(temp);
 204             return temp;
 205         });
 206
 207         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 208         [EditorBrowsable(EditorBrowsableState.Never)]
 209         public static readonly BindableProperty EnableMarkupProperty = BindableProperty.Create(nameof(EnableMarkup), typeof(bool), typeof(TextLabel), false, propertyChanged: (bindable, oldValue, newValue) =>
 210         {
 211             var textLabel = (TextLabel)bindable;
 212             if (newValue != null)
 213             {
 214                 Tizen.NUI.Object.SetProperty(textLabel.swigCPtr, TextLabel.Property.ENABLE_MARKUP, new Tizen.NUI.PropertyValue((bool)newValue));
 215             }
 216         },
 217         defaultValueCreator: (bindable) =>
 218         {
 219             var textLabel = (TextLabel)bindable;
 220             bool temp = false;
 221             Tizen.NUI.Object.GetProperty(textLabel.swigCPtr, TextLabel.Property.ENABLE_MARKUP).Get(out temp);
 222             return temp;
 223         });
 224         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 225         [EditorBrowsable(EditorBrowsableState.Never)]
 226         public static readonly BindableProperty EnableAutoScrollProperty = BindableProperty.Create(nameof(EnableAutoScroll), typeof(bool), typeof(TextLabel), false, propertyChanged: (bindable, oldValue, newValue) =>
 227         {
 228             var textLabel = (TextLabel)bindable;
 229             if (newValue != null)
 230             {
 231                 Tizen.NUI.Object.SetProperty(textLabel.swigCPtr, TextLabel.Property.ENABLE_AUTO_SCROLL, new Tizen.NUI.PropertyValue((bool)newValue));
 232             }
 233         },
 234         defaultValueCreator: (bindable) =>
 235         {
 236             var textLabel = (TextLabel)bindable;
 237             bool temp = false;
 238             Tizen.NUI.Object.GetProperty(textLabel.swigCPtr, TextLabel.Property.ENABLE_AUTO_SCROLL).Get(out temp);
 239             return temp;
 240         });
 241         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 242         [EditorBrowsable(EditorBrowsableState.Never)]
 243         public static readonly BindableProperty AutoScrollSpeedProperty = BindableProperty.Create(nameof(AutoScrollSpeed), typeof(int), typeof(TextLabel), default(int), propertyChanged: (bindable, oldValue, newValue) =>
 244         {
 245             var textLabel = (TextLabel)bindable;
 246             if (newValue != null)
 247             {
 248                 Tizen.NUI.Object.SetProperty(textLabel.swigCPtr, TextLabel.Property.AUTO_SCROLL_SPEED, new Tizen.NUI.PropertyValue((int)newValue));
 249             }
 250         },
 251         defaultValueCreator: (bindable) =>
 252         {
 253             var textLabel = (TextLabel)bindable;
 254             int temp = 0;
 255             Tizen.NUI.Object.GetProperty(textLabel.swigCPtr, TextLabel.Property.AUTO_SCROLL_SPEED).Get(out temp);
 256             return temp;
 257         });
 258         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 259         [EditorBrowsable(EditorBrowsableState.Never)]
 260         public static readonly BindableProperty AutoScrollLoopCountProperty = BindableProperty.Create(nameof(AutoScrollLoopCount), typeof(int), typeof(TextLabel), default(int), propertyChanged: (bindable, oldValue, newValue) =>
 261         {
 262             var textLabel = (TextLabel)bindable;
 263             if (newValue != null)
 264             {
 265                 Tizen.NUI.Object.SetProperty(textLabel.swigCPtr, TextLabel.Property.AUTO_SCROLL_LOOP_COUNT, new Tizen.NUI.PropertyValue((int)newValue));
 266             }
 267         },
 268         defaultValueCreator: (bindable) =>
 269         {
 270             var textLabel = (TextLabel)bindable;
 271             int temp = 0;
 272             Tizen.NUI.Object.GetProperty(textLabel.swigCPtr, TextLabel.Property.AUTO_SCROLL_LOOP_COUNT).Get(out temp);
 273             return temp;
 274         });
 275         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 276         [EditorBrowsable(EditorBrowsableState.Never)]
 277         public static readonly BindableProperty AutoScrollGapProperty = BindableProperty.Create(nameof(AutoScrollGap), typeof(float), typeof(TextLabel), default(float), propertyChanged: (bindable, oldValue, newValue) =>
 278         {
 279             var textLabel = (TextLabel)bindable;
 280             if (newValue != null)
 281             {
 282                 Tizen.NUI.Object.SetProperty(textLabel.swigCPtr, TextLabel.Property.AUTO_SCROLL_GAP, new Tizen.NUI.PropertyValue((float)newValue));
 283             }
 284         },
 285         defaultValueCreator: (bindable) =>
 286         {
 287             var textLabel = (TextLabel)bindable;
 288             float temp = 0.0f;
 289             Tizen.NUI.Object.GetProperty(textLabel.swigCPtr, TextLabel.Property.AUTO_SCROLL_GAP).Get(out temp);
 290             return temp;
 291         });
 292         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 293         [EditorBrowsable(EditorBrowsableState.Never)]
 294         public static readonly BindableProperty LineSpacingProperty = BindableProperty.Create(nameof(LineSpacing), typeof(float), typeof(TextLabel), default(float), propertyChanged: (bindable, oldValue, newValue) =>
 295         {
 296             var textLabel = (TextLabel)bindable;
 297             if (newValue != null)
 298             {
 299                 Tizen.NUI.Object.SetProperty(textLabel.swigCPtr, TextLabel.Property.LINE_SPACING, new Tizen.NUI.PropertyValue((float)newValue));
 300             }
 301         },
 302         defaultValueCreator: (bindable) =>
 303         {
 304             var textLabel = (TextLabel)bindable;
 305             float temp = 0.0f;
 306             Tizen.NUI.Object.GetProperty(textLabel.swigCPtr, TextLabel.Property.LINE_SPACING).Get(out temp);
 307             return temp;
 308         });
 309         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 310         [EditorBrowsable(EditorBrowsableState.Never)]
 311         public static readonly BindableProperty UnderlineProperty = BindableProperty.Create(nameof(Underline), typeof(PropertyMap), typeof(TextLabel), null, propertyChanged: (bindable, oldValue, newValue) =>
 312         {
 313             var textLabel = (TextLabel)bindable;
 314             if (newValue != null)
 315             {
 316                 Tizen.NUI.Object.SetProperty(textLabel.swigCPtr, TextLabel.Property.UNDERLINE, new Tizen.NUI.PropertyValue((PropertyMap)newValue));
 317             }
 318         },
 319         defaultValueCreator: (bindable) =>
 320         {
 321             var textLabel = (TextLabel)bindable;
 322             PropertyMap temp = new PropertyMap();
 323             Tizen.NUI.Object.GetProperty(textLabel.swigCPtr, TextLabel.Property.UNDERLINE).Get(temp);
 324             return temp;
 325         });
 326         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 327         [EditorBrowsable(EditorBrowsableState.Never)]
 328         public static readonly BindableProperty ShadowProperty = BindableProperty.Create(nameof(Shadow), typeof(PropertyMap), typeof(TextLabel), null, propertyChanged: (bindable, oldValue, newValue) =>
 329         {
 330             var textLabel = (TextLabel)bindable;
 331             if (newValue != null)
 332             {
 333                 Tizen.NUI.Object.SetProperty(textLabel.swigCPtr, TextLabel.Property.SHADOW, new Tizen.NUI.PropertyValue((PropertyMap)newValue));
 334             }
 335         },
 336         defaultValueCreator: (bindable) =>
 337         {
 338             var textLabel = (TextLabel)bindable;
 339             PropertyMap temp = new PropertyMap();
 340             Tizen.NUI.Object.GetProperty(textLabel.swigCPtr, TextLabel.Property.SHADOW).Get(temp);
 341             return temp;
 342         });
 343         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 344         [EditorBrowsable(EditorBrowsableState.Never)]
 345         public static readonly BindableProperty EmbossProperty = BindableProperty.Create(nameof(Emboss), typeof(string), typeof(TextLabel), string.Empty, propertyChanged: (bindable, oldValue, newValue) =>
 346         {
 347             var textLabel = (TextLabel)bindable;
 348             if (newValue != null)
 349             {
 350                 Tizen.NUI.Object.SetProperty(textLabel.swigCPtr, TextLabel.Property.EMBOSS, new Tizen.NUI.PropertyValue((string)newValue));
 351             }
 352         },
 353         defaultValueCreator: (bindable) =>
 354         {
 355             var textLabel = (TextLabel)bindable;
 356             string temp;
 357             Tizen.NUI.Object.GetProperty(textLabel.swigCPtr, TextLabel.Property.EMBOSS).Get(out temp);
 358             return temp;
 359         });
 360         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 361         [EditorBrowsable(EditorBrowsableState.Never)]
 362         public static readonly BindableProperty OutlineProperty = BindableProperty.Create(nameof(Outline), typeof(PropertyMap), typeof(TextLabel), null, propertyChanged: (bindable, oldValue, newValue) =>
 363         {
 364             var textLabel = (TextLabel)bindable;
 365             if (newValue != null)
 366             {
 367                 Tizen.NUI.Object.SetProperty(textLabel.swigCPtr, TextLabel.Property.OUTLINE, new Tizen.NUI.PropertyValue((PropertyMap)newValue));
 368             }
 369         },
 370         defaultValueCreator: (bindable) =>
 371         {
 372             var textLabel = (TextLabel)bindable;
 373             PropertyMap temp = new PropertyMap();
 374             Tizen.NUI.Object.GetProperty(textLabel.swigCPtr, TextLabel.Property.OUTLINE).Get(temp);
 375             return temp;
 376         });
 377         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 378         [EditorBrowsable(EditorBrowsableState.Never)]
 379         public static readonly BindableProperty PixelSizeProperty = BindableProperty.Create(nameof(PixelSize), typeof(float), typeof(TextLabel), default(float), propertyChanged: (bindable, oldValue, newValue) =>
 380         {
 381             var textLabel = (TextLabel)bindable;
 382             if (newValue != null)
 383             {
 384                 Tizen.NUI.Object.SetProperty(textLabel.swigCPtr, TextLabel.Property.PIXEL_SIZE, new Tizen.NUI.PropertyValue((float)newValue));
 385             }
 386         },
 387         defaultValueCreator: (bindable) =>
 388         {
 389             var textLabel = (TextLabel)bindable;
 390             float temp = 0.0f;
 391             Tizen.NUI.Object.GetProperty(textLabel.swigCPtr, TextLabel.Property.PIXEL_SIZE).Get(out temp);
 392             return temp;
 393         });
 394         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 395         [EditorBrowsable(EditorBrowsableState.Never)]
 396         public static readonly BindableProperty EllipsisProperty = BindableProperty.Create(nameof(Ellipsis), typeof(bool), typeof(TextLabel), false, propertyChanged: (bindable, oldValue, newValue) =>
 397         {
 398             var textLabel = (TextLabel)bindable;
 399             if (newValue != null)
 400             {
 401                 Tizen.NUI.Object.SetProperty(textLabel.swigCPtr, TextLabel.Property.ELLIPSIS, new Tizen.NUI.PropertyValue((bool)newValue));
 402             }
 403         },
 404         defaultValueCreator: (bindable) =>
 405         {
 406             var textLabel = (TextLabel)bindable;
 407             bool temp = false;
 408             Tizen.NUI.Object.GetProperty(textLabel.swigCPtr, TextLabel.Property.ELLIPSIS).Get(out temp);
 409             return temp;
 410         });
 411         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 412         [EditorBrowsable(EditorBrowsableState.Never)]
 413         public static readonly BindableProperty AutoScrollLoopDelayProperty = BindableProperty.Create(nameof(AutoScrollLoopDelay), typeof(float), typeof(TextLabel), default(float), propertyChanged: (bindable, oldValue, newValue) =>
 414         {
 415             var textLabel = (TextLabel)bindable;
 416             if (newValue != null)
 417             {
 418                 Tizen.NUI.Object.SetProperty(textLabel.swigCPtr, TextLabel.Property.AUTO_SCROLL_LOOP_DELAY, new Tizen.NUI.PropertyValue((float)newValue));
 419             }
 420         },
 421         defaultValueCreator: (bindable) =>
 422         {
 423             var textLabel = (TextLabel)bindable;
 424             float temp = 0.0f;
 425             Tizen.NUI.Object.GetProperty(textLabel.swigCPtr, TextLabel.Property.AUTO_SCROLL_LOOP_DELAY).Get(out temp);
 426             return temp;
 427         });
 428         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 429         [EditorBrowsable(EditorBrowsableState.Never)]
 430         public static readonly BindableProperty AutoScrollStopModeProperty = BindableProperty.Create(nameof(AutoScrollStopMode), typeof(AutoScrollStopMode), typeof(TextLabel), AutoScrollStopMode.FinishLoop, propertyChanged: (bindable, oldValue, newValue) =>
 431         {
 432             var textLabel = (TextLabel)bindable;
 433             if (newValue != null)
 434             {
 435                 Tizen.NUI.Object.SetProperty(textLabel.swigCPtr, TextLabel.Property.AUTO_SCROLL_STOP_MODE, new Tizen.NUI.PropertyValue((int)newValue));
 436             }
 437         },
 438         defaultValueCreator: (bindable) =>
 439         {
 440             var textLabel = (TextLabel)bindable;
 441             string temp;
 442             if (Tizen.NUI.Object.GetProperty(textLabel.swigCPtr, TextLabel.Property.AUTO_SCROLL_STOP_MODE).Get(out temp) == false)
 443             {
 444                 NUILog.Error("AutoScrollStopMode get error!");
 445             }
 446             switch (temp)
 447             {
 448                 case "FINISH_LOOP": return AutoScrollStopMode.FinishLoop;
 449                 case "IMMEDIATE": return AutoScrollStopMode.Immediate;
 450                 default: return AutoScrollStopMode.FinishLoop;
 451             }
 452         });
 453         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 454         [EditorBrowsable(EditorBrowsableState.Never)]
 455         public static readonly BindableProperty LineWrapModeProperty = BindableProperty.Create(nameof(LineWrapMode), typeof(LineWrapMode), typeof(TextLabel), LineWrapMode.Word, propertyChanged: (bindable, oldValue, newValue) =>
 456         {
 457             var textLabel = (TextLabel)bindable;
 458             if (newValue != null)
 459             {
 460                 Tizen.NUI.Object.SetProperty(textLabel.swigCPtr, TextLabel.Property.LINE_WRAP_MODE, new Tizen.NUI.PropertyValue((int)newValue));
 461             }
 462         },
 463         defaultValueCreator: (bindable) =>
 464         {
 465             var textLabel = (TextLabel)bindable;
 466             int temp;
 467             if (false == Tizen.NUI.Object.GetProperty(textLabel.swigCPtr, TextLabel.Property.LINE_WRAP_MODE).Get(out temp))
 468             {
 469                 NUILog.Error("LineWrapMode get error!");
 470             }
 471             return (LineWrapMode)temp;
 472         });
 473         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 474         [EditorBrowsable(EditorBrowsableState.Never)]
 475         public static readonly BindableProperty VerticalLineAlignmentProperty = BindableProperty.Create(nameof(VerticalLineAlignment), typeof(VerticalLineAlignment), typeof(TextLabel), VerticalLineAlignment.Bottom, propertyChanged: (bindable, oldValue, newValue) =>
 476         {
 477             var textLabel = (TextLabel)bindable;
 478             if (newValue != null)
 479             {
 480                 Tizen.NUI.Object.SetProperty(textLabel.swigCPtr, TextLabel.Property.VERTICAL_LINE_ALIGNMENT, new Tizen.NUI.PropertyValue((int)newValue));
 481             }
 482         },
 483         defaultValueCreator: (bindable) =>
 484         {
 485             var textLabel = (TextLabel)bindable;
 486             int temp = 0;
 487             Tizen.NUI.Object.GetProperty(textLabel.swigCPtr, TextLabel.Property.VERTICAL_LINE_ALIGNMENT).Get(out temp);
 488             return (VerticalLineAlignment)temp;
 489         });
 490         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 491         [EditorBrowsable(EditorBrowsableState.Never)]
 492         public static readonly BindableProperty MatchSystemLanguageDirectionProperty = BindableProperty.Create(nameof(MatchSystemLanguageDirection), typeof(bool), typeof(TextLabel), false, propertyChanged: (bindable, oldValue, newValue) =>
 493         {
 494             var textLabel = (TextLabel)bindable;
 495             if (newValue != null)
 496             {
 497                 Tizen.NUI.Object.SetProperty(textLabel.swigCPtr, TextLabel.Property.MATCH_SYSTEM_LANGUAGE_DIRECTION, new Tizen.NUI.PropertyValue((bool)newValue));
 498             }
 499         },
 500         defaultValueCreator: (bindable) =>
 501         {
 502             var textLabel = (TextLabel)bindable;
 503             bool temp = false;
 504             Tizen.NUI.Object.GetProperty(textLabel.swigCPtr, TextLabel.Property.MATCH_SYSTEM_LANGUAGE_DIRECTION).Get(out temp);
 505             return temp;
 506         });
 507
 508         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
 509         private string textLabelSid = null;
 510         private bool systemlangTextFlag = false;
 511
 512         /// <summary>
 513         /// Creates the TextLabel control.
 514         /// </summary>
 515         /// <since_tizen> 3 </since_tizen>
 516         public TextLabel() : this(NDalicPINVOKE.TextLabel_New__SWIG_0(), true)
 517         {
 518             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 519         }
 520
 521         /// <summary>
 522         /// Creates the TextLabel control.
 523         /// </summary>
 524         /// <param name="text">The text to display</param>
 525         /// <since_tizen> 3 </since_tizen>
 526         public TextLabel(string text) : this(NDalicPINVOKE.TextLabel_New__SWIG_1(text), true)
 527         {
 528             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 529         }
 530
 531         internal TextLabel(TextLabel handle) : this(NDalicPINVOKE.new_TextLabel__SWIG_1(TextLabel.getCPtr(handle)), true)
 532         {
 533             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 534         }
 535
 536         internal TextLabel(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.TextLabel_SWIGUpcast(cPtr), cMemoryOwn)
 537         {
 538             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
 539         }
 540
 541         /// <summary>
 542         /// The TranslatableText property.<br />
 543         /// The text can set the SID value.<br />
 544         /// </summary>
 545         /// <exception cref='ArgumentNullException'>
 546         /// ResourceManager about multilingual is null.
 547         /// </exception>
 548         /// <since_tizen> 4 </since_tizen>
 549         public string TranslatableText
 550         {
 551             get
 552             {
 553                 return textLabelSid;
 554             }
 555             set
 556             {
 557                 if (NUIApplication.MultilingualResourceManager == null)
 558                 {
 559                     throw new ArgumentNullException("ResourceManager about multilingual is null");
 560                 }
 561                 string translatableText = null;
 562                 textLabelSid = value;
 563                 translatableText = NUIApplication.MultilingualResourceManager?.GetString(textLabelSid, new CultureInfo(SystemSettings.LocaleLanguage.Replace("_", "-")));
 564                 if (translatableText != null)
 565                 {
 566                     Text = translatableText;
 567                     if (systemlangTextFlag == false)
 568                     {
 569                         SystemSettings.LocaleLanguageChanged += new WeakEventHandler<LocaleLanguageChangedEventArgs>(SystemSettings_LocaleLanguageChanged).Handler;
 570                         systemlangTextFlag = true;
 571                     }
 572                 }
 573                 else
 574                 {
 575                     Text = "";
 576                 }
 577                 NotifyPropertyChanged();
 578             }
 579         }
 580
 581         /// <summary>
 582         /// The Text property.<br />
 583         /// The text to display in the UTF-8 format.<br />
 584         /// </summary>
 585         /// <since_tizen> 3 </since_tizen>
 586         public string Text
 587         {
 588             get
 589             {
 590                 return (string)GetValue(TextProperty);
 591             }
 592             set
 593             {
 594                 SetValue(TextProperty, value);
 595                 NotifyPropertyChanged();
 596             }
 597         }
 598
 599         /// <summary>
 600         /// The FontFamily property.<br />
 601         /// The requested font family to use.<br />
 602         /// </summary>
 603         /// <since_tizen> 3 </since_tizen>
 604         public string FontFamily
 605         {
 606             get
 607             {
 608                 return (string)GetValue(FontFamilyProperty);
 609             }
 610             set
 611             {
 612                 SetValue(FontFamilyProperty, value);
 613                 NotifyPropertyChanged();
 614             }
 615         }
 616
 617         /// <summary>
 618         /// The FontStyle property.<br />
 619         /// The requested font style to use.<br />
 620         /// </summary>
 621         /// <since_tizen> 3 </since_tizen>
 622         public PropertyMap FontStyle
 623         {
 624             get
 625             {
 626                 return (PropertyMap)GetValue(FontStyleProperty);
 627             }
 628             set
 629             {
 630                 SetValue(FontStyleProperty, value);
 631                 NotifyPropertyChanged();
 632             }
 633         }
 634
 635         /// <summary>
 636         /// The PointSize property.<br />
 637         /// The size of font in points.<br />
 638         /// </summary>
 639         /// <since_tizen> 3 </since_tizen>
 640         public float PointSize
 641         {
 642             get
 643             {
 644                 return (float)GetValue(PointSizeProperty);
 645             }
 646             set
 647             {
 648                 SetValue(PointSizeProperty, value);
 649                 NotifyPropertyChanged();
 650             }
 651         }
 652
 653         /// <summary>
 654         /// The MultiLine property.<br />
 655         /// The single-line or multi-line layout option.<br />
 656         /// </summary>
 657         /// <since_tizen> 3 </since_tizen>
 658         public bool MultiLine
 659         {
 660             get
 661             {
 662                 return (bool)GetValue(MultiLineProperty);
 663             }
 664             set
 665             {
 666                 SetValue(MultiLineProperty, value);
 667                 NotifyPropertyChanged();
 668             }
 669         }
 670
 671         /// <summary>
 672         /// The HorizontalAlignment property.<br />
 673         /// The line horizontal alignment.<br />
 674         /// </summary>
 675         /// <since_tizen> 3 </since_tizen>
 676         public HorizontalAlignment HorizontalAlignment
 677         {
 678             get
 679             {
 680                 return (HorizontalAlignment)GetValue(HorizontalAlignmentProperty);
 681             }
 682             set
 683             {
 684                 SetValue(HorizontalAlignmentProperty, value);
 685                 NotifyPropertyChanged();
 686             }
 687         }
 688
 689         /// <summary>
 690         /// The VerticalAlignment property.<br />
 691         /// The line vertical alignment.<br />
 692         /// </summary>
 693         /// <since_tizen> 3 </since_tizen>
 694         public VerticalAlignment VerticalAlignment
 695         {
 696             get
 697             {
 698                 return (VerticalAlignment)GetValue(VerticalAlignmentProperty);
 699             }
 700             set
 701             {
 702                 SetValue(VerticalAlignmentProperty, value);
 703                 NotifyPropertyChanged();
 704             }
 705         }
 706
 707         /// <summary>
 708         /// The TextColor property.<br />
 709         /// The color of the text.<br />
 710         /// Animation framework can be used to change the color of the text when not using mark up.<br />
 711         /// Cannot animate the color when text is auto scrolling.<br />
 712         /// </summary>
 713         /// <since_tizen> 3 </since_tizen>
 714         public Color TextColor
 715         {
 716             get
 717             {
 718                 return (Color)GetValue(TextColorProperty);
 719             }
 720             set
 721             {
 722                 SetValue(TextColorProperty, value);
 723                 NotifyPropertyChanged();
 724             }
 725         }
 726
 727         /// <summary>
 728         /// The ShadowOffset property.<br />
 729         /// The drop shadow offset 0 indicates no shadow.<br />
 730         /// </summary>
 731         /// <since_tizen> 3 </since_tizen>
 732         [Obsolete("Please do not use! This will be deprecated! Please use Shadow property instead!")]
 733         [EditorBrowsable(EditorBrowsableState.Never)]
 734         public Vector2 ShadowOffset
 735         {
 736             get
 737             {
 738                 Vector2 shadowOffset = new Vector2();
 739                 Shadow.Find(TextLabel.Property.SHADOW, "offset")?.Get(shadowOffset);
 740                 return shadowOffset;
 741             }
 742             set
 743             {
 744                 PropertyMap temp = new PropertyMap();
 745                 temp.Insert("offset", new PropertyValue(value));
 746
 747                 PropertyMap shadowMap = Shadow;
 748                 shadowMap.Merge(temp);
 749
 750                 SetValue(ShadowProperty, shadowMap);
 751                 NotifyPropertyChanged();
 752             }
 753         }
 754
 755         /// <summary>
 756         /// The ShadowColor property.<br />
 757         /// The color of a drop shadow.<br />
 758         /// </summary>
 759         /// <since_tizen> 3 </since_tizen>
 760         [Obsolete("Please do not use! This will be deprecated! Please use Shadow property instead!")]
 761         [EditorBrowsable(EditorBrowsableState.Never)]
 762         public Vector4 ShadowColor
 763         {
 764             get
 765             {
 766                 Vector4 shadowColor = new Vector4();
 767                 Shadow.Find(TextLabel.Property.SHADOW, "color")?.Get(shadowColor);
 768                 return shadowColor;
 769             }
 770             set
 771             {
 772                 PropertyMap temp = new PropertyMap();
 773                 temp.Insert("color", new PropertyValue(value));
 774
 775                 PropertyMap shadowMap = Shadow;
 776                 shadowMap.Merge(temp);
 777
 778                 SetValue(ShadowProperty, shadowMap);
 779                 NotifyPropertyChanged();
 780             }
 781         }
 782
 783         /// <summary>
 784         /// The UnderlineEnabled property.<br />
 785         /// The underline enabled flag.<br />
 786         /// </summary>
 787         /// <since_tizen> 3 </since_tizen>
 788         [Obsolete("Please do not use! This will be deprecated! Please use Underline property instead!")]
 789         [EditorBrowsable(EditorBrowsableState.Never)]
 790         public bool UnderlineEnabled
 791         {
 792             get
 793             {
 794                 bool underlineEnabled = false;
 795                 Underline.Find(TextLabel.Property.UNDERLINE, "enable")?.Get(out underlineEnabled);
 796                 return underlineEnabled;
 797             }
 798             set
 799             {
 800                 PropertyMap temp = new PropertyMap();
 801                 temp.Add("enable", new PropertyValue(value));
 802
 803                 PropertyMap undelineMap = Underline;
 804                 undelineMap.Merge(temp);
 805
 806                 SetValue(UnderlineProperty, undelineMap);
 807                 NotifyPropertyChanged();
 808
 809             }
 810         }
 811
 812         /// <summary>
 813         /// The UnderlineColor property.<br />
 814         /// Overrides the underline height from font metrics.<br />
 815         /// </summary>
 816         /// <since_tizen> 3 </since_tizen>
 817         [Obsolete("Please do not use! This will be deprecated! Please use Underline property instead!")]
 818         [EditorBrowsable(EditorBrowsableState.Never)]
 819         public Vector4 UnderlineColor
 820         {
 821             get
 822             {
 823                 Vector4 underlineColor = new Vector4();
 824                 Underline.Find(TextLabel.Property.UNDERLINE, "color")?.Get(underlineColor);
 825                 return underlineColor;
 826             }
 827             set
 828             {
 829                 PropertyMap temp = new PropertyMap();
 830                 temp.Insert("color", new PropertyValue(value));
 831
 832                 PropertyMap undelineMap = Underline;
 833                 undelineMap.Merge(temp);
 834
 835                 SetValue(UnderlineProperty, undelineMap);
 836                 NotifyPropertyChanged();
 837             }
 838         }
 839
 840         /// <summary>
 841         /// The UnderlineHeight property.<br />
 842         /// Overrides the underline height from font metrics.<br />
 843         /// </summary>
 844         /// <since_tizen> 3 </since_tizen>
 845         [Obsolete("Please do not use! This will be deprecated! Please use Underline property instead!")]
 846         [EditorBrowsable(EditorBrowsableState.Never)]
 847         public float UnderlineHeight
 848         {
 849             get
 850             {
 851                 float underlineHeight = 0.0f;
 852                 Underline.Find(TextLabel.Property.UNDERLINE, "height")?.Get(out underlineHeight);
 853                 return underlineHeight;
 854             }
 855             set
 856             {
 857                 PropertyMap temp = new PropertyMap();
 858                 temp.Insert("height", new PropertyValue(value));
 859
 860                 PropertyMap undelineMap = Underline;
 861                 undelineMap.Merge(temp);
 862
 863                 SetValue(UnderlineProperty, undelineMap);
 864                 NotifyPropertyChanged();
 865             }
 866         }
 867
 868         /// <summary>
 869         /// The EnableMarkup property.<br />
 870         /// Whether the mark-up processing is enabled.<br />
 871         /// </summary>
 872         /// <since_tizen> 3 </since_tizen>
 873         public bool EnableMarkup
 874         {
 875             get
 876             {
 877                 return (bool)GetValue(EnableMarkupProperty);
 878             }
 879             set
 880             {
 881                 SetValue(EnableMarkupProperty, value);
 882                 NotifyPropertyChanged();
 883             }
 884         }
 885
 886         /// <summary>
 887         /// The EnableAutoScroll property.<br />
 888         /// Starts or stops auto scrolling.<br />
 889         /// </summary>
 890         /// <since_tizen> 3 </since_tizen>
 891         public bool EnableAutoScroll
 892         {
 893             get
 894             {
 895                 return (bool)GetValue(EnableAutoScrollProperty);
 896             }
 897             set
 898             {
 899                 SetValue(EnableAutoScrollProperty, value);
 900                 NotifyPropertyChanged();
 901             }
 902         }
 903
 904         /// <summary>
 905         /// The AutoScrollSpeed property.<br />
 906         /// Sets the speed of scrolling in pixels per second.<br />
 907         /// </summary>
 908         /// <since_tizen> 3 </since_tizen>
 909         public int AutoScrollSpeed
 910         {
 911             get
 912             {
 913                 return (int)GetValue(AutoScrollSpeedProperty);
 914             }
 915             set
 916             {
 917                 SetValue(AutoScrollSpeedProperty, value);
 918                 NotifyPropertyChanged();
 919             }
 920         }
 921
 922         /// <summary>
 923         /// The AutoScrollLoopCount property.<br />
 924         /// Number of complete loops when scrolling enabled.<br />
 925         /// </summary>
 926         /// <since_tizen> 3 </since_tizen>
 927         public int AutoScrollLoopCount
 928         {
 929             get
 930             {
 931                 return (int)GetValue(AutoScrollLoopCountProperty);
 932             }
 933             set
 934             {
 935                 SetValue(AutoScrollLoopCountProperty, value);
 936                 NotifyPropertyChanged();
 937             }
 938         }
 939
 940         /// <summary>
 941         /// The AutoScrollGap property.<br />
 942         /// Gap before scrolling wraps.<br />
 943         /// </summary>
 944         /// <since_tizen> 3 </since_tizen>
 945         public float AutoScrollGap
 946         {
 947             get
 948             {
 949                 return (float)GetValue(AutoScrollGapProperty);
 950             }
 951             set
 952             {
 953                 SetValue(AutoScrollGapProperty, value);
 954                 NotifyPropertyChanged();
 955             }
 956         }
 957
 958         /// <summary>
 959         /// The LineSpacing property.<br />
 960         /// The default extra space between lines in points.<br />
 961         /// </summary>
 962         /// <since_tizen> 3 </since_tizen>
 963         public float LineSpacing
 964         {
 965             get
 966             {
 967                 return (float)GetValue(LineSpacingProperty);
 968             }
 969             set
 970             {
 971                 SetValue(LineSpacingProperty, value);
 972                 NotifyPropertyChanged();
 973             }
 974         }
 975
 976         /// <summary>
 977         /// The Underline property.<br />
 978         /// The default underline parameters.<br />
 979         /// </summary>
 980         /// <since_tizen> 3 </since_tizen>
 981         public PropertyMap Underline
 982         {
 983             get
 984             {
 985                 return (PropertyMap)GetValue(UnderlineProperty);
 986             }
 987             set
 988             {
 989                 SetValue(UnderlineProperty, value);
 990                 NotifyPropertyChanged();
 991             }
 992         }
 993
 994         /// <summary>
 995         /// The Shadow property.<br />
 996         /// The default shadow parameters.<br />
 997         /// </summary>
 998         /// <since_tizen> 3 </since_tizen>
 999         public PropertyMap Shadow
1000         {
1001             get
1002             {
1003                 return (PropertyMap)GetValue(ShadowProperty);
1004             }
1005             set
1006             {
1007                 SetValue(ShadowProperty, value);
1008                 NotifyPropertyChanged();
1009             }
1010         }
1011
1012         /// <summary>
1013         /// The Emboss property.<br />
1014         /// The default emboss parameters.<br />
1015         /// </summary>
1016         /// <since_tizen> 3 </since_tizen>
1017         public string Emboss
1018         {
1019             get
1020             {
1021                 return (string)GetValue(EmbossProperty);
1022             }
1023             set
1024             {
1025                 SetValue(EmbossProperty, value);
1026                 NotifyPropertyChanged();
1027             }
1028         }
1029
1030         /// <summary>
1031         /// The Outline property.<br />
1032         /// The default outline parameters.<br />
1033         /// </summary>
1034         /// <since_tizen> 3 </since_tizen>
1035         public PropertyMap Outline
1036         {
1037             get
1038             {
1039                 return (PropertyMap)GetValue(OutlineProperty);
1040             }
1041             set
1042             {
1043                 SetValue(OutlineProperty, value);
1044                 NotifyPropertyChanged();
1045             }
1046         }
1047
1048         /// <summary>
1049         /// The PixelSize property.<br />
1050         /// The size of font in pixels.<br />
1051         /// </summary>
1052         /// <since_tizen> 3 </since_tizen>
1053         public float PixelSize
1054         {
1055             get
1056             {
1057                 return (float)GetValue(PixelSizeProperty);
1058             }
1059             set
1060             {
1061                 SetValue(PixelSizeProperty, value);
1062                 NotifyPropertyChanged();
1063             }
1064         }
1065
1066         /// <summary>
1067         /// The Ellipsis property.<br />
1068         /// Enable or disable the ellipsis.<br />
1069         /// </summary>
1070         /// <since_tizen> 3 </since_tizen>
1071         public bool Ellipsis
1072         {
1073             get
1074             {
1075                 return (bool)GetValue(EllipsisProperty);
1076             }
1077             set
1078             {
1079                 SetValue(EllipsisProperty, value);
1080                 NotifyPropertyChanged();
1081             }
1082         }
1083
1084         /// <summary>
1085         /// The AutoScrollLoopDelay property.<br />
1086         /// Do something.<br />
1087         /// </summary>
1088         /// <since_tizen> 3 </since_tizen>
1089         public float AutoScrollLoopDelay
1090         {
1091             get
1092             {
1093                 return (float)GetValue(AutoScrollLoopDelayProperty);
1094             }
1095             set
1096             {
1097                 SetValue(AutoScrollLoopDelayProperty, value);
1098                 NotifyPropertyChanged();
1099             }
1100         }
1101
1102         /// <summary>
1103         /// The AutoScrollStopMode property.<br />
1104         /// Do something.<br />
1105         /// </summary>
1106         /// <since_tizen> 3 </since_tizen>
1107         public AutoScrollStopMode AutoScrollStopMode
1108         {
1109             get
1110             {
1111                 return (AutoScrollStopMode)GetValue(AutoScrollStopModeProperty);
1112             }
1113             set
1114             {
1115                 SetValue(AutoScrollStopModeProperty, value);
1116                 NotifyPropertyChanged();
1117             }
1118         }
1119
1120         /// <summary>
1121         /// The line count of the text.
1122         /// </summary>
1123         /// <since_tizen> 3 </since_tizen>
1124         public int LineCount
1125         {
1126             get
1127             {
1128                 int temp = 0;
1129                 GetProperty(TextLabel.Property.LINE_COUNT).Get(out temp);
1130                 return temp;
1131             }
1132         }
1133
1134         /// <summary>
1135         /// The LineWrapMode property.<br />
1136         /// line wrap mode when the text lines over layout width.<br />
1137         /// </summary>
1138         /// <since_tizen> 4 </since_tizen>
1139         public LineWrapMode LineWrapMode
1140         {
1141             get
1142             {
1143                 return (LineWrapMode)GetValue(LineWrapModeProperty);
1144             }
1145             set
1146             {
1147                 SetValue(LineWrapModeProperty, value);
1148                 NotifyPropertyChanged();
1149             }
1150         }
1151
1152         /// <summary>
1153         /// The direction of the text such as left to right or right to left.
1154         /// </summary>
1155         /// <since_tizen> 5 </since_tizen>
1156         /// This will be released at Tizen.NET API Level 5, so currently this would be used as inhouse API.
1157         [EditorBrowsable(EditorBrowsableState.Never)]
1158         public TextDirection TextDirection
1159         {
1160             get
1161             {
1162                 int temp = 0;
1163                 GetProperty(TextLabel.Property.TEXT_DIRECTION).Get(out temp);
1164                 return (TextDirection)temp;
1165             }
1166         }
1167
1168         /// <summary>
1169         /// The vertical line alignment of the text.
1170         /// </summary>
1171         /// <since_tizen> 5 </since_tizen>
1172         /// This will be released at Tizen.NET API Level 5, so currently this would be used as inhouse API.
1173         [EditorBrowsable(EditorBrowsableState.Never)]
1174         public VerticalLineAlignment VerticalLineAlignment
1175         {
1176             get
1177             {
1178                 return (VerticalLineAlignment)GetValue(VerticalLineAlignmentProperty);
1179             }
1180             set
1181             {
1182                 SetValue(VerticalLineAlignmentProperty, value);
1183                 NotifyPropertyChanged();
1184             }
1185         }
1186
1187         /// <summary>
1188         /// The text alignment to match the direction of the system language.
1189         /// </summary>
1190         /// <since_tizen> 5 </since_tizen>
1191         /// This will be released at Tizen.NET API Level 5, so currently this would be used as inhouse API.
1192         [EditorBrowsable(EditorBrowsableState.Never)]
1193         public bool MatchSystemLanguageDirection
1194         {
1195             get
1196             {
1197                 return (bool)GetValue(MatchSystemLanguageDirectionProperty);
1198             }
1199             set
1200             {
1201                 SetValue(MatchSystemLanguageDirectionProperty, value);
1202                 NotifyPropertyChanged();
1203             }
1204         }
1205
1206         /// <summary>
1207         /// Downcasts a handle to textLabel handle
1208         /// </summary>
1209         /// <param name="handle"></param>
1210         /// <returns></returns>
1211         /// <since_tizen> 3 </since_tizen>
1212         /// Please do not use! this will be deprecated!
1213         /// Instead please use as keyword.
1214         [Obsolete("Please do not use! This will be deprecated! Please use as keyword instead! " +
1215             "Like: " +
1216             "BaseHandle handle = new TextLabel(\"Hello World!\"); " +
1217             "TextLabel label = handle as TextLabel")]
1218         [EditorBrowsable(EditorBrowsableState.Never)]
1219         public static TextLabel DownCast(BaseHandle handle)
1220         {
1221             TextLabel ret = Registry.GetManagedBaseHandleFromNativePtr(handle) as TextLabel;
1222
1223             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1224             return ret;
1225         }
1226
1227         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(TextLabel obj)
1228         {
1229             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
1230         }
1231
1232         /// <summary>
1233         /// Dispose.
1234         /// </summary>
1235         /// <since_tizen> 3 </since_tizen>
1236         protected override void Dispose(DisposeTypes type)
1237         {
1238             if (disposed)
1239             {
1240                 return;
1241             }
1242
1243             if (type == DisposeTypes.Explicit)
1244             {
1245                 //Called by User
1246                 //Release your own managed resources here.
1247                 //You should release all of your own disposable objects here.
1248             }
1249
1250             //Release your own unmanaged resources here.
1251             //You should not access any managed member here except static instance.
1252             //because the execution order of Finalizes is non-deterministic.
1253
1254             if (swigCPtr.Handle != global::System.IntPtr.Zero)
1255             {
1256                 if (swigCMemOwn)
1257                 {
1258                     swigCMemOwn = false;
1259                     NDalicPINVOKE.delete_TextLabel(swigCPtr);
1260                 }
1261                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
1262             }
1263
1264             base.Dispose(type);
1265         }
1266
1267         /// <summary>
1268         /// Invoked whenever the binding context of the textlabel changes. Implement this method to add class handling for this event.
1269         /// </summary>
1270         protected override void OnBindingContextChanged()
1271         {
1272             base.OnBindingContextChanged();
1273         }
1274
1275         private void SystemSettings_LocaleLanguageChanged(object sender, LocaleLanguageChangedEventArgs e)
1276         {
1277             Text = NUIApplication.MultilingualResourceManager?.GetString(textLabelSid, new CultureInfo(e.Value.Replace("_", "-")));
1278         }
1279
1280         internal new class Property
1281         {
1282             internal static readonly int RENDERING_BACKEND = NDalicPINVOKE.TextLabel_Property_RENDERING_BACKEND_get();
1283             internal static readonly int TEXT = NDalicPINVOKE.TextLabel_Property_TEXT_get();
1284             internal static readonly int FONT_FAMILY = NDalicPINVOKE.TextLabel_Property_FONT_FAMILY_get();
1285             internal static readonly int FONT_STYLE = NDalicPINVOKE.TextLabel_Property_FONT_STYLE_get();
1286             internal static readonly int POINT_SIZE = NDalicPINVOKE.TextLabel_Property_POINT_SIZE_get();
1287             internal static readonly int MULTI_LINE = NDalicPINVOKE.TextLabel_Property_MULTI_LINE_get();
1288             internal static readonly int HORIZONTAL_ALIGNMENT = NDalicPINVOKE.TextLabel_Property_HORIZONTAL_ALIGNMENT_get();
1289             internal static readonly int VERTICAL_ALIGNMENT = NDalicPINVOKE.TextLabel_Property_VERTICAL_ALIGNMENT_get();
1290             internal static readonly int TEXT_COLOR = NDalicPINVOKE.TextLabel_Property_TEXT_COLOR_get();
1291             internal static readonly int ENABLE_MARKUP = NDalicPINVOKE.TextLabel_Property_ENABLE_MARKUP_get();
1292             internal static readonly int ENABLE_AUTO_SCROLL = NDalicPINVOKE.TextLabel_Property_ENABLE_AUTO_SCROLL_get();
1293             internal static readonly int AUTO_SCROLL_SPEED = NDalicPINVOKE.TextLabel_Property_AUTO_SCROLL_SPEED_get();
1294             internal static readonly int AUTO_SCROLL_LOOP_COUNT = NDalicPINVOKE.TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get();
1295             internal static readonly int AUTO_SCROLL_GAP = NDalicPINVOKE.TextLabel_Property_AUTO_SCROLL_GAP_get();
1296             internal static readonly int LINE_SPACING = NDalicPINVOKE.TextLabel_Property_LINE_SPACING_get();
1297             internal static readonly int UNDERLINE = NDalicPINVOKE.TextLabel_Property_UNDERLINE_get();
1298             internal static readonly int SHADOW = NDalicPINVOKE.TextLabel_Property_SHADOW_get();
1299             internal static readonly int EMBOSS = NDalicPINVOKE.TextLabel_Property_EMBOSS_get();
1300             internal static readonly int OUTLINE = NDalicPINVOKE.TextLabel_Property_OUTLINE_get();
1301             internal static readonly int PIXEL_SIZE = NDalicManualPINVOKE.TextLabel_Property_PIXEL_SIZE_get();
1302             internal static readonly int ELLIPSIS = NDalicManualPINVOKE.TextLabel_Property_ELLIPSIS_get();
1303             internal static readonly int AUTO_SCROLL_STOP_MODE = NDalicManualPINVOKE.TextLabel_Property_AUTO_SCROLL_STOP_MODE_get();
1304             internal static readonly int AUTO_SCROLL_LOOP_DELAY = NDalicManualPINVOKE.TextLabel_Property_AUTO_SCROLL_LOOP_DELAY_get();
1305             internal static readonly int LINE_COUNT = NDalicManualPINVOKE.TextLabel_Property_LINE_COUNT_get();
1306             internal static readonly int LINE_WRAP_MODE = NDalicManualPINVOKE.TextLabel_Property_LINE_WRAP_MODE_get();
1307             internal static readonly int TEXT_DIRECTION = NDalicManualPINVOKE.TextLabel_Property_TEXT_DIRECTION_get();
1308             internal static readonly int VERTICAL_LINE_ALIGNMENT = NDalicManualPINVOKE.TextLabel_Property_VERTICAL_LINE_ALIGNMENT_get();
1309             internal static readonly int MATCH_SYSTEM_LANGUAGE_DIRECTION = NDalicManualPINVOKE.TextLabel_Property_MATCH_SYSTEM_LANGUAGE_DIRECTION_get();
1310         }
1311     }
1312 }