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         /// Only for XAML. No need of public API. Make hidden as inhouse API.
 509         [EditorBrowsable(EditorBrowsableState.Never)]
 510         public static readonly BindableProperty TextFitProperty = BindableProperty.Create(nameof(TextFit), typeof(PropertyMap), typeof(TextLabel), null, propertyChanged: (bindable, oldValue, newValue) =>
 511         {
 512             var textLabel = (TextLabel)bindable;
 513             if (newValue != null)
 514             {
 515                 Tizen.NUI.Object.SetProperty(textLabel.swigCPtr, TextLabel.Property.TEXT_FIT, new Tizen.NUI.PropertyValue((PropertyMap)newValue));
 516             }
 517         },
 518         defaultValueCreator: (bindable) =>
 519         {
 520             var textLabel = (TextLabel)bindable;
 521             PropertyMap temp = new PropertyMap();
 522             Tizen.NUI.Object.GetProperty(textLabel.swigCPtr, TextLabel.Property.TEXT_FIT).Get(temp);
 523             return temp;
 524         });
 525
 526         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
 527         private string textLabelSid = null;
 528         private bool systemlangTextFlag = false;
 529
 530         /// <summary>
 531         /// Creates the TextLabel control.
 532         /// </summary>
 533         /// <since_tizen> 3 </since_tizen>
 534         public TextLabel() : this(Interop.TextLabel.TextLabel_New__SWIG_0(), true)
 535         {
 536             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 537         }
 538
 539         /// <summary>
 540         /// Creates the TextLabel control.
 541         /// </summary>
 542         /// <param name="text">The text to display</param>
 543         /// <since_tizen> 3 </since_tizen>
 544         public TextLabel(string text) : this(Interop.TextLabel.TextLabel_New__SWIG_1(text), true)
 545         {
 546             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 547         }
 548
 549         internal TextLabel(TextLabel handle) : this(Interop.TextLabel.new_TextLabel__SWIG_1(TextLabel.getCPtr(handle)), true)
 550         {
 551             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 552         }
 553
 554         internal TextLabel(global::System.IntPtr cPtr, bool cMemoryOwn) : base(Interop.TextLabel.TextLabel_SWIGUpcast(cPtr), cMemoryOwn)
 555         {
 556             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
 557         }
 558
 559         /// <summary>
 560         /// The TranslatableText property.<br />
 561         /// The text can set the SID value.<br />
 562         /// </summary>
 563         /// <exception cref='ArgumentNullException'>
 564         /// ResourceManager about multilingual is null.
 565         /// </exception>
 566         /// <since_tizen> 4 </since_tizen>
 567         public string TranslatableText
 568         {
 569             get
 570             {
 571                 return textLabelSid;
 572             }
 573             set
 574             {
 575                 if (NUIApplication.MultilingualResourceManager == null)
 576                 {
 577                     throw new ArgumentNullException("ResourceManager about multilingual is null");
 578                 }
 579                 string translatableText = null;
 580                 textLabelSid = value;
 581                 translatableText = NUIApplication.MultilingualResourceManager?.GetString(textLabelSid, new CultureInfo(SystemSettings.LocaleLanguage.Replace("_", "-")));
 582                 if (translatableText != null)
 583                 {
 584                     Text = translatableText;
 585                     if (systemlangTextFlag == false)
 586                     {
 587                         SystemSettings.LocaleLanguageChanged += new WeakEventHandler<LocaleLanguageChangedEventArgs>(SystemSettings_LocaleLanguageChanged).Handler;
 588                         systemlangTextFlag = true;
 589                     }
 590                 }
 591                 else
 592                 {
 593                     Text = "";
 594                 }
 595                 NotifyPropertyChanged();
 596             }
 597         }
 598
 599         /// <summary>
 600         /// The Text property.<br />
 601         /// The text to display in the UTF-8 format.<br />
 602         /// </summary>
 603         /// <since_tizen> 3 </since_tizen>
 604         public string Text
 605         {
 606             get
 607             {
 608                 return (string)GetValue(TextProperty);
 609             }
 610             set
 611             {
 612                 SetValue(TextProperty, value);
 613                 NotifyPropertyChangedAndRequestLayout();
 614             }
 615         }
 616
 617         /// <summary>
 618         /// The FontFamily property.<br />
 619         /// The requested font family to use.<br />
 620         /// </summary>
 621         /// <since_tizen> 3 </since_tizen>
 622         public string FontFamily
 623         {
 624             get
 625             {
 626                 return (string)GetValue(FontFamilyProperty);
 627             }
 628             set
 629             {
 630                 SetValue(FontFamilyProperty, value);
 631                 NotifyPropertyChangedAndRequestLayout();
 632             }
 633         }
 634
 635         /// <summary>
 636         /// The FontStyle property.<br />
 637         /// The requested font style to use.<br />
 638         /// </summary>
 639         /// <since_tizen> 3 </since_tizen>
 640         public PropertyMap FontStyle
 641         {
 642             get
 643             {
 644                 return (PropertyMap)GetValue(FontStyleProperty);
 645             }
 646             set
 647             {
 648                 SetValue(FontStyleProperty, value);
 649                 NotifyPropertyChangedAndRequestLayout();
 650             }
 651         }
 652
 653         /// <summary>
 654         /// The PointSize property.<br />
 655         /// The size of font in points.<br />
 656         /// </summary>
 657         /// <since_tizen> 3 </since_tizen>
 658         public float PointSize
 659         {
 660             get
 661             {
 662                 return (float)GetValue(PointSizeProperty);
 663             }
 664             set
 665             {
 666                 SetValue(PointSizeProperty, value);
 667                 NotifyPropertyChangedAndRequestLayout();
 668             }
 669         }
 670
 671         /// <summary>
 672         /// The MultiLine property.<br />
 673         /// The single-line or multi-line layout option.<br />
 674         /// </summary>
 675         /// <since_tizen> 3 </since_tizen>
 676         public bool MultiLine
 677         {
 678             get
 679             {
 680                 return (bool)GetValue(MultiLineProperty);
 681             }
 682             set
 683             {
 684                 SetValue(MultiLineProperty, value);
 685                 NotifyPropertyChangedAndRequestLayout();
 686             }
 687         }
 688
 689         /// <summary>
 690         /// The HorizontalAlignment property.<br />
 691         /// The line horizontal alignment.<br />
 692         /// </summary>
 693         /// <since_tizen> 3 </since_tizen>
 694         public HorizontalAlignment HorizontalAlignment
 695         {
 696             get
 697             {
 698                 return (HorizontalAlignment)GetValue(HorizontalAlignmentProperty);
 699             }
 700             set
 701             {
 702                 SetValue(HorizontalAlignmentProperty, value);
 703                 NotifyPropertyChanged();
 704             }
 705         }
 706
 707         /// <summary>
 708         /// The VerticalAlignment property.<br />
 709         /// The line vertical alignment.<br />
 710         /// </summary>
 711         /// <since_tizen> 3 </since_tizen>
 712         public VerticalAlignment VerticalAlignment
 713         {
 714             get
 715             {
 716                 return (VerticalAlignment)GetValue(VerticalAlignmentProperty);
 717             }
 718             set
 719             {
 720                 SetValue(VerticalAlignmentProperty, value);
 721                 NotifyPropertyChanged();
 722             }
 723         }
 724
 725         /// <summary>
 726         /// The TextColor property.<br />
 727         /// The color of the text.<br />
 728         /// Animation framework can be used to change the color of the text when not using mark up.<br />
 729         /// Cannot animate the color when text is auto scrolling.<br />
 730         /// </summary>
 731         /// <since_tizen> 3 </since_tizen>
 732         public Color TextColor
 733         {
 734             get
 735             {
 736                 return (Color)GetValue(TextColorProperty);
 737             }
 738             set
 739             {
 740                 SetValue(TextColorProperty, value);
 741                 NotifyPropertyChanged();
 742             }
 743         }
 744
 745         /// <summary>
 746         /// The ShadowOffset property.<br />
 747         /// The drop shadow offset 0 indicates no shadow.<br />
 748         /// </summary>
 749         /// <since_tizen> 3 </since_tizen>
 750         /// <remarks>
 751         /// Deprecated.(API Level 6) Use Shadow instead.
 752         /// </remarks>
 753         [Obsolete("Please do not use this ShadowOffset(Deprecated). Please use Shadow instead.")]
 754         public Vector2 ShadowOffset
 755         {
 756             get
 757             {
 758                 Vector2 shadowOffset = new Vector2();
 759                 Shadow.Find(TextLabel.Property.SHADOW, "offset")?.Get(shadowOffset);
 760                 return shadowOffset;
 761             }
 762             set
 763             {
 764                 PropertyMap temp = new PropertyMap();
 765                 temp.Insert("offset", new PropertyValue(value));
 766
 767                 PropertyMap shadowMap = Shadow;
 768                 shadowMap.Merge(temp);
 769
 770                 SetValue(ShadowProperty, shadowMap);
 771                 NotifyPropertyChanged();
 772             }
 773         }
 774
 775         /// <summary>
 776         /// The ShadowColor property.<br />
 777         /// The color of a drop shadow.<br />
 778         /// </summary>
 779         /// <since_tizen> 3 </since_tizen>
 780         /// <remarks>
 781         /// Deprecated.(API Level 6) Use Shadow instead.
 782         /// </remarks>
 783         [Obsolete("Please do not use this ShadowColor(Deprecated). Please use Shadow instead.")]
 784         public Vector4 ShadowColor
 785         {
 786             get
 787             {
 788                 Vector4 shadowColor = new Vector4();
 789                 Shadow.Find(TextLabel.Property.SHADOW, "color")?.Get(shadowColor);
 790                 return shadowColor;
 791             }
 792             set
 793             {
 794                 PropertyMap temp = new PropertyMap();
 795                 temp.Insert("color", new PropertyValue(value));
 796
 797                 PropertyMap shadowMap = Shadow;
 798                 shadowMap.Merge(temp);
 799
 800                 SetValue(ShadowProperty, shadowMap);
 801                 NotifyPropertyChanged();
 802             }
 803         }
 804
 805         /// <summary>
 806         /// The UnderlineEnabled property.<br />
 807         /// The underline enabled flag.<br />
 808         /// </summary>
 809         /// <since_tizen> 3 </since_tizen>
 810         /// <remarks>
 811         /// Deprecated.(API Level 6) Use Underline instead.
 812         /// </remarks>
 813         [Obsolete("Please do not use this UnderlineEnabled(Deprecated). Please use Underline instead.")]
 814         public bool UnderlineEnabled
 815         {
 816             get
 817             {
 818                 bool underlineEnabled = false;
 819                 Underline.Find(TextLabel.Property.UNDERLINE, "enable")?.Get(out underlineEnabled);
 820                 return underlineEnabled;
 821             }
 822             set
 823             {
 824                 PropertyMap temp = new PropertyMap();
 825                 temp.Add("enable", new PropertyValue(value));
 826
 827                 PropertyMap undelineMap = Underline;
 828                 undelineMap.Merge(temp);
 829
 830                 SetValue(UnderlineProperty, undelineMap);
 831                 NotifyPropertyChanged();
 832
 833             }
 834         }
 835
 836         /// <summary>
 837         /// The UnderlineColor property.<br />
 838         /// Overrides the underline height from font metrics.<br />
 839         /// </summary>
 840         /// <since_tizen> 3 </since_tizen>
 841         /// <remarks>
 842         /// Deprecated.(API Level 6) Use Underline instead.
 843         /// </remarks>
 844         [Obsolete("Please do not use this UnderlineColor(Deprecated). Please use Underline instead.")]
 845         public Vector4 UnderlineColor
 846         {
 847             get
 848             {
 849                 Vector4 underlineColor = new Vector4();
 850                 Underline.Find(TextLabel.Property.UNDERLINE, "color")?.Get(underlineColor);
 851                 return underlineColor;
 852             }
 853             set
 854             {
 855                 PropertyMap temp = new PropertyMap();
 856                 temp.Insert("color", new PropertyValue(value));
 857
 858                 PropertyMap undelineMap = Underline;
 859                 undelineMap.Merge(temp);
 860
 861                 SetValue(UnderlineProperty, undelineMap);
 862                 NotifyPropertyChanged();
 863             }
 864         }
 865
 866         /// <summary>
 867         /// The UnderlineHeight property.<br />
 868         /// Overrides the underline height from font metrics.<br />
 869         /// </summary>
 870         /// <since_tizen> 3 </since_tizen>
 871         /// <remarks>
 872         /// Deprecated.(API Level 6) Use Underline instead.
 873         /// </remarks>
 874         [Obsolete("Please do not use this UnderlineHeight(Deprecated). Please use Underline instead.")]
 875         public float UnderlineHeight
 876         {
 877             get
 878             {
 879                 float underlineHeight = 0.0f;
 880                 Underline.Find(TextLabel.Property.UNDERLINE, "height")?.Get(out underlineHeight);
 881                 return underlineHeight;
 882             }
 883             set
 884             {
 885                 PropertyMap temp = new PropertyMap();
 886                 temp.Insert("height", new PropertyValue(value));
 887
 888                 PropertyMap undelineMap = Underline;
 889                 undelineMap.Merge(temp);
 890
 891                 SetValue(UnderlineProperty, undelineMap);
 892                 NotifyPropertyChanged();
 893             }
 894         }
 895
 896         /// <summary>
 897         /// The EnableMarkup property.<br />
 898         /// Whether the mark-up processing is enabled.<br />
 899         /// </summary>
 900         /// <since_tizen> 3 </since_tizen>
 901         public bool EnableMarkup
 902         {
 903             get
 904             {
 905                 return (bool)GetValue(EnableMarkupProperty);
 906             }
 907             set
 908             {
 909                 SetValue(EnableMarkupProperty, value);
 910                 NotifyPropertyChanged();
 911             }
 912         }
 913
 914         /// <summary>
 915         /// The EnableAutoScroll property.<br />
 916         /// Starts or stops auto scrolling.<br />
 917         /// </summary>
 918         /// <since_tizen> 3 </since_tizen>
 919         public bool EnableAutoScroll
 920         {
 921             get
 922             {
 923                 return (bool)GetValue(EnableAutoScrollProperty);
 924             }
 925             set
 926             {
 927                 SetValue(EnableAutoScrollProperty, value);
 928                 NotifyPropertyChanged();
 929             }
 930         }
 931
 932         /// <summary>
 933         /// The AutoScrollSpeed property.<br />
 934         /// Sets the speed of scrolling in pixels per second.<br />
 935         /// </summary>
 936         /// <since_tizen> 3 </since_tizen>
 937         public int AutoScrollSpeed
 938         {
 939             get
 940             {
 941                 return (int)GetValue(AutoScrollSpeedProperty);
 942             }
 943             set
 944             {
 945                 SetValue(AutoScrollSpeedProperty, value);
 946                 NotifyPropertyChanged();
 947             }
 948         }
 949
 950         /// <summary>
 951         /// The AutoScrollLoopCount property.<br />
 952         /// Number of complete loops when scrolling enabled.<br />
 953         /// </summary>
 954         /// <since_tizen> 3 </since_tizen>
 955         public int AutoScrollLoopCount
 956         {
 957             get
 958             {
 959                 return (int)GetValue(AutoScrollLoopCountProperty);
 960             }
 961             set
 962             {
 963                 SetValue(AutoScrollLoopCountProperty, value);
 964                 NotifyPropertyChanged();
 965             }
 966         }
 967
 968         /// <summary>
 969         /// The AutoScrollGap property.<br />
 970         /// Gap before scrolling wraps.<br />
 971         /// </summary>
 972         /// <since_tizen> 3 </since_tizen>
 973         public float AutoScrollGap
 974         {
 975             get
 976             {
 977                 return (float)GetValue(AutoScrollGapProperty);
 978             }
 979             set
 980             {
 981                 SetValue(AutoScrollGapProperty, value);
 982                 NotifyPropertyChanged();
 983             }
 984         }
 985
 986         /// <summary>
 987         /// The LineSpacing property.<br />
 988         /// The default extra space between lines in points.<br />
 989         /// </summary>
 990         /// <since_tizen> 3 </since_tizen>
 991         public float LineSpacing
 992         {
 993             get
 994             {
 995                 return (float)GetValue(LineSpacingProperty);
 996             }
 997             set
 998             {
 999                 SetValue(LineSpacingProperty, value);
1000                 NotifyPropertyChangedAndRequestLayout();
1001             }
1002         }
1003
1004         /// <summary>
1005         /// The Underline property.<br />
1006         /// The default underline parameters.<br />
1007         /// </summary>
1008         /// <since_tizen> 3 </since_tizen>
1009         public PropertyMap Underline
1010         {
1011             get
1012             {
1013                 return (PropertyMap)GetValue(UnderlineProperty);
1014             }
1015             set
1016             {
1017                 SetValue(UnderlineProperty, value);
1018                 NotifyPropertyChanged();
1019             }
1020         }
1021
1022         /// <summary>
1023         /// The Shadow property.<br />
1024         /// The default shadow parameters.<br />
1025         /// </summary>
1026         /// <since_tizen> 3 </since_tizen>
1027         public PropertyMap Shadow
1028         {
1029             get
1030             {
1031                 return (PropertyMap)GetValue(ShadowProperty);
1032             }
1033             set
1034             {
1035                 SetValue(ShadowProperty, value);
1036                 NotifyPropertyChanged();
1037             }
1038         }
1039
1040         /// <summary>
1041         /// The Emboss property.<br />
1042         /// The default emboss parameters.<br />
1043         /// </summary>
1044         /// <since_tizen> 3 </since_tizen>
1045         public string Emboss
1046         {
1047             get
1048             {
1049                 return (string)GetValue(EmbossProperty);
1050             }
1051             set
1052             {
1053                 SetValue(EmbossProperty, value);
1054                 NotifyPropertyChanged();
1055             }
1056         }
1057
1058         /// <summary>
1059         /// The Outline property.<br />
1060         /// The default outline parameters.<br />
1061         /// </summary>
1062         /// <since_tizen> 3 </since_tizen>
1063         public PropertyMap Outline
1064         {
1065             get
1066             {
1067                 return (PropertyMap)GetValue(OutlineProperty);
1068             }
1069             set
1070             {
1071                 SetValue(OutlineProperty, value);
1072                 NotifyPropertyChanged();
1073             }
1074         }
1075
1076         /// <summary>
1077         /// The PixelSize property.<br />
1078         /// The size of font in pixels.<br />
1079         /// </summary>
1080         /// <since_tizen> 3 </since_tizen>
1081         public float PixelSize
1082         {
1083             get
1084             {
1085                 return (float)GetValue(PixelSizeProperty);
1086             }
1087             set
1088             {
1089                 SetValue(PixelSizeProperty, value);
1090                 NotifyPropertyChangedAndRequestLayout();
1091             }
1092         }
1093
1094         /// <summary>
1095         /// The Ellipsis property.<br />
1096         /// Enable or disable the ellipsis.<br />
1097         /// </summary>
1098         /// <since_tizen> 3 </since_tizen>
1099         public bool Ellipsis
1100         {
1101             get
1102             {
1103                 return (bool)GetValue(EllipsisProperty);
1104             }
1105             set
1106             {
1107                 SetValue(EllipsisProperty, value);
1108                 NotifyPropertyChanged();
1109             }
1110         }
1111
1112         /// <summary>
1113         /// The AutoScrollLoopDelay property.<br />
1114         /// Do something.<br />
1115         /// </summary>
1116         /// <since_tizen> 3 </since_tizen>
1117         public float AutoScrollLoopDelay
1118         {
1119             get
1120             {
1121                 return (float)GetValue(AutoScrollLoopDelayProperty);
1122             }
1123             set
1124             {
1125                 SetValue(AutoScrollLoopDelayProperty, value);
1126                 NotifyPropertyChanged();
1127             }
1128         }
1129
1130         /// <summary>
1131         /// The AutoScrollStopMode property.<br />
1132         /// Do something.<br />
1133         /// </summary>
1134         /// <since_tizen> 3 </since_tizen>
1135         public AutoScrollStopMode AutoScrollStopMode
1136         {
1137             get
1138             {
1139                 return (AutoScrollStopMode)GetValue(AutoScrollStopModeProperty);
1140             }
1141             set
1142             {
1143                 SetValue(AutoScrollStopModeProperty, value);
1144                 NotifyPropertyChanged();
1145             }
1146         }
1147
1148         /// <summary>
1149         /// The line count of the text.
1150         /// </summary>
1151         /// <since_tizen> 3 </since_tizen>
1152         public int LineCount
1153         {
1154             get
1155             {
1156                 int temp = 0;
1157                 GetProperty(TextLabel.Property.LINE_COUNT).Get(out temp);
1158                 return temp;
1159             }
1160         }
1161
1162         /// <summary>
1163         /// The LineWrapMode property.<br />
1164         /// line wrap mode when the text lines over layout width.<br />
1165         /// </summary>
1166         /// <since_tizen> 4 </since_tizen>
1167         public LineWrapMode LineWrapMode
1168         {
1169             get
1170             {
1171                 return (LineWrapMode)GetValue(LineWrapModeProperty);
1172             }
1173             set
1174             {
1175                 SetValue(LineWrapModeProperty, value);
1176                 NotifyPropertyChanged();
1177             }
1178         }
1179
1180         /// <summary>
1181         /// The direction of the text such as left to right or right to left.
1182         /// </summary>
1183         /// <since_tizen> 5 </since_tizen>
1184         /// This will be released at Tizen.NET API Level 5, so currently this would be used as inhouse API.
1185         [EditorBrowsable(EditorBrowsableState.Never)]
1186         public TextDirection TextDirection
1187         {
1188             get
1189             {
1190                 int temp = 0;
1191                 GetProperty(TextLabel.Property.TEXT_DIRECTION).Get(out temp);
1192                 return (TextDirection)temp;
1193             }
1194         }
1195
1196         /// <summary>
1197         /// The vertical line alignment of the text.
1198         /// </summary>
1199         /// <since_tizen> 5 </since_tizen>
1200         /// This will be released at Tizen.NET API Level 5, so currently this would be used as inhouse API.
1201         [EditorBrowsable(EditorBrowsableState.Never)]
1202         public VerticalLineAlignment VerticalLineAlignment
1203         {
1204             get
1205             {
1206                 return (VerticalLineAlignment)GetValue(VerticalLineAlignmentProperty);
1207             }
1208             set
1209             {
1210                 SetValue(VerticalLineAlignmentProperty, value);
1211                 NotifyPropertyChanged();
1212             }
1213         }
1214
1215         /// <summary>
1216         /// The text alignment to match the direction of the system language.
1217         /// </summary>
1218         /// <since_tizen> 6 </since_tizen>
1219         public bool MatchSystemLanguageDirection
1220         {
1221             get
1222             {
1223                 return (bool)GetValue(MatchSystemLanguageDirectionProperty);
1224             }
1225             set
1226             {
1227                 SetValue(MatchSystemLanguageDirectionProperty, value);
1228                 NotifyPropertyChanged();
1229             }
1230         }
1231
1232         /// <summary>
1233         /// The text fit parameters.<br />
1234         /// The textFit map contains the following keys :<br />
1235         /// - enable (bool type) : True to enable the text fit or false to disable(the default value is false)<br />
1236         /// - minSize (float type) : Minimum Size for text fit(the default value is 10.f)<br />
1237         /// - maxSize (float type) : Maximum Size for text fit(the default value is 100.f)<br />
1238         /// - stepSize (float type) : Step Size for font increase(the default value is 1.f)<br />
1239         /// - fontSize (string type) : The size type of font, You can choose between "pointSize" or "pixelSize". (the default value is "pointSize")<br />
1240         /// </summary>
1241         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
1242         [EditorBrowsable(EditorBrowsableState.Never)]
1243         public PropertyMap TextFit
1244         {
1245             get
1246             {
1247                 return (PropertyMap)GetValue(TextFitProperty);
1248             }
1249             set
1250             {
1251                 SetValue(TextFitProperty, value);
1252                 NotifyPropertyChanged();
1253             }
1254         }
1255
1256         /// <summary>
1257         /// Downcasts a handle to textLabel handle
1258         /// </summary>
1259         /// <param name="handle"></param>
1260         /// <returns></returns>
1261         /// <since_tizen> 3 </since_tizen>
1262         /// Please do not use! this will be deprecated!
1263         /// Instead please use as keyword.
1264         [Obsolete("Please do not use! This will be deprecated! Please use as keyword instead! " +
1265             "Like: " +
1266             "BaseHandle handle = new TextLabel(\"Hello World!\"); " +
1267             "TextLabel label = handle as TextLabel")]
1268         [EditorBrowsable(EditorBrowsableState.Never)]
1269         public static TextLabel DownCast(BaseHandle handle)
1270         {
1271             TextLabel ret = Registry.GetManagedBaseHandleFromNativePtr(handle) as TextLabel;
1272
1273             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1274             return ret;
1275         }
1276
1277         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(TextLabel obj)
1278         {
1279             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
1280         }
1281
1282         /// <summary>
1283         /// Dispose.
1284         /// </summary>
1285         /// <since_tizen> 3 </since_tizen>
1286         protected override void Dispose(DisposeTypes type)
1287         {
1288             if (disposed)
1289             {
1290                 return;
1291             }
1292
1293             if (type == DisposeTypes.Explicit)
1294             {
1295                 //Called by User
1296                 //Release your own managed resources here.
1297                 //You should release all of your own disposable objects here.
1298             }
1299
1300             //Release your own unmanaged resources here.
1301             //You should not access any managed member here except static instance.
1302             //because the execution order of Finalizes is non-deterministic.
1303
1304             if (swigCPtr.Handle != global::System.IntPtr.Zero)
1305             {
1306                 if (swigCMemOwn)
1307                 {
1308                     swigCMemOwn = false;
1309                     Interop.TextLabel.delete_TextLabel(swigCPtr);
1310                 }
1311                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
1312             }
1313
1314             base.Dispose(type);
1315         }
1316
1317         /// <summary>
1318         /// Invoked whenever the binding context of the textlabel changes. Implement this method to add class handling for this event.
1319         /// </summary>
1320         protected override void OnBindingContextChanged()
1321         {
1322             base.OnBindingContextChanged();
1323         }
1324
1325         private void SystemSettings_LocaleLanguageChanged(object sender, LocaleLanguageChangedEventArgs e)
1326         {
1327             Text = NUIApplication.MultilingualResourceManager?.GetString(textLabelSid, new CultureInfo(e.Value.Replace("_", "-")));
1328         }
1329
1330         private void  NotifyPropertyChangedAndRequestLayout()
1331         {
1332             NotifyPropertyChanged();
1333             Layout?.RequestLayout();
1334         }
1335
1336         internal new class Property
1337         {
1338             internal static readonly int RENDERING_BACKEND = Interop.TextLabel.TextLabel_Property_RENDERING_BACKEND_get();
1339             internal static readonly int TEXT = Interop.TextLabel.TextLabel_Property_TEXT_get();
1340             internal static readonly int FONT_FAMILY = Interop.TextLabel.TextLabel_Property_FONT_FAMILY_get();
1341             internal static readonly int FONT_STYLE = Interop.TextLabel.TextLabel_Property_FONT_STYLE_get();
1342             internal static readonly int POINT_SIZE = Interop.TextLabel.TextLabel_Property_POINT_SIZE_get();
1343             internal static readonly int MULTI_LINE = Interop.TextLabel.TextLabel_Property_MULTI_LINE_get();
1344             internal static readonly int HORIZONTAL_ALIGNMENT = Interop.TextLabel.TextLabel_Property_HORIZONTAL_ALIGNMENT_get();
1345             internal static readonly int VERTICAL_ALIGNMENT = Interop.TextLabel.TextLabel_Property_VERTICAL_ALIGNMENT_get();
1346             internal static readonly int TEXT_COLOR = Interop.TextLabel.TextLabel_Property_TEXT_COLOR_get();
1347             internal static readonly int ENABLE_MARKUP = Interop.TextLabel.TextLabel_Property_ENABLE_MARKUP_get();
1348             internal static readonly int ENABLE_AUTO_SCROLL = Interop.TextLabel.TextLabel_Property_ENABLE_AUTO_SCROLL_get();
1349             internal static readonly int AUTO_SCROLL_SPEED = Interop.TextLabel.TextLabel_Property_AUTO_SCROLL_SPEED_get();
1350             internal static readonly int AUTO_SCROLL_LOOP_COUNT = Interop.TextLabel.TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get();
1351             internal static readonly int AUTO_SCROLL_GAP = Interop.TextLabel.TextLabel_Property_AUTO_SCROLL_GAP_get();
1352             internal static readonly int LINE_SPACING = Interop.TextLabel.TextLabel_Property_LINE_SPACING_get();
1353             internal static readonly int UNDERLINE = Interop.TextLabel.TextLabel_Property_UNDERLINE_get();
1354             internal static readonly int SHADOW = Interop.TextLabel.TextLabel_Property_SHADOW_get();
1355             internal static readonly int EMBOSS = Interop.TextLabel.TextLabel_Property_EMBOSS_get();
1356             internal static readonly int OUTLINE = Interop.TextLabel.TextLabel_Property_OUTLINE_get();
1357             internal static readonly int PIXEL_SIZE = Interop.TextLabel.TextLabel_Property_PIXEL_SIZE_get();
1358             internal static readonly int ELLIPSIS = Interop.TextLabel.TextLabel_Property_ELLIPSIS_get();
1359             internal static readonly int AUTO_SCROLL_STOP_MODE = Interop.TextLabel.TextLabel_Property_AUTO_SCROLL_STOP_MODE_get();
1360             internal static readonly int AUTO_SCROLL_LOOP_DELAY = Interop.TextLabel.TextLabel_Property_AUTO_SCROLL_LOOP_DELAY_get();
1361             internal static readonly int LINE_COUNT = Interop.TextLabel.TextLabel_Property_LINE_COUNT_get();
1362             internal static readonly int LINE_WRAP_MODE = Interop.TextLabel.TextLabel_Property_LINE_WRAP_MODE_get();
1363             internal static readonly int TEXT_DIRECTION = Interop.TextLabel.TextLabel_Property_TEXT_DIRECTION_get();
1364             internal static readonly int VERTICAL_LINE_ALIGNMENT = Interop.TextLabel.TextLabel_Property_VERTICAL_LINE_ALIGNMENT_get();
1365             internal static readonly int MATCH_SYSTEM_LANGUAGE_DIRECTION = Interop.TextLabel.TextLabel_Property_MATCH_SYSTEM_LANGUAGE_DIRECTION_get();
1366             internal static readonly int TEXT_FIT = Interop.TextLabel.TextLabel_Property_TEXT_FIT_get();
1367         }
1368     }
1369 }