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