src/ElmSharp/ElmSharp/Entry.cs

   1 /*
   2  * Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
   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 using System;
  18 using System.Collections.Generic;
  19 using System.Runtime.InteropServices;
  20
  21 namespace ElmSharp
  22 {
  23     /// <summary>
  24     /// Enumeration for describing InputPanel layout type.
  25     /// </summary>
  26     public enum InputPanelLayout
  27     {
  28         /// <summary>
  29         /// InputPanel layout type default.
  30         /// </summary>
  31         Normal,
  32
  33         /// <summary>
  34         /// InputPanel layout type number.
  35         /// </summary>
  36         Number,
  37
  38         /// <summary>
  39         /// InputPanel layout type email.
  40         /// </summary>
  41         Email,
  42
  43         /// <summary>
  44         /// InputPanel layout type url.
  45         /// </summary>
  46         Url,
  47
  48         /// <summary>
  49         /// InputPanel layout type phone.
  50         /// </summary>
  51         PhoneNumber,
  52
  53         /// <summary>
  54         /// InputPanel layout type ip.
  55         /// </summary>
  56         Ip,
  57
  58         /// <summary>
  59         /// InputPanel layout type month.
  60         /// </summary>
  61         Month,
  62
  63         /// <summary>
  64         /// InputPanel layout type number.
  65         /// </summary>
  66         NumberOnly,
  67
  68         /// <summary>
  69         /// InputPanel layout type error type. Do not use it directly!
  70         /// </summary>
  71         Invalid,
  72
  73         /// <summary>
  74         /// InputPanel layout type hexadecimal.
  75         /// </summary>
  76         Hex,
  77
  78         /// <summary>
  79         /// InputPanel layout type terminal type, esc, alt, ctrl, etc.
  80         /// </summary>
  81         Terminal,
  82
  83         /// <summary>
  84         /// InputPanel layout type password.
  85         /// </summary>
  86         Password,
  87
  88         /// <summary>
  89         /// Keyboard layout type date and time.
  90         /// </summary>
  91         DateTime,
  92
  93         /// <summary>
  94         /// InputPanel layout type emoticons.
  95         /// </summary>
  96         Emoticon
  97     }
  98
  99     /// <summary>
 100     /// Enumeration that defines the "Return" key types on the input panel (virtual keyboard).
 101     /// </summary>
 102     public enum InputPanelReturnKeyType
 103     {
 104         /// <summary>
 105         /// Default key type
 106         /// </summary>
 107         Default,
 108
 109         /// <summary>
 110         /// Done key type
 111         /// </summary>
 112         Done,
 113
 114         /// <summary>
 115         /// Go key type
 116         /// </summary>
 117         Go,
 118
 119         /// <summary>
 120         /// Join key type
 121         /// </summary>
 122         Join,
 123
 124         /// <summary>
 125         /// Login key type
 126         /// </summary>
 127         Login,
 128
 129         /// <summary>
 130         /// Next key type
 131         /// </summary>
 132         Next,
 133
 134         /// <summary>
 135         /// Search string or magnifier icon key type
 136         /// </summary>
 137         Search,
 138
 139         /// <summary>
 140         /// Send key type
 141         /// </summary>
 142         Send,
 143
 144         /// <summary>
 145         /// Sign-in key type
 146         /// </summary>
 147         Signin
 148     }
 149
 150     /// <summary>
 151     /// Enumeration that defines the autocapitalization types.
 152     /// </summary>
 153     public enum AutoCapital
 154     {
 155         /// <summary>
 156         /// No autocapitalization when typing
 157         /// </summary>
 158         None,
 159
 160         /// <summary>
 161         /// Autocapitalize each typed word
 162         /// </summary>
 163         Word,
 164
 165         /// <summary>
 166         /// Autocapitalize the start of each sentence
 167         /// </summary>
 168         Sentence,
 169
 170         /// <summary>
 171         /// Autocapitalize all letters
 172         /// </summary>
 173         All
 174     }
 175
 176     /// <summary>
 177     /// Enumeration that defines the entry's copy & paste policy.
 178     /// </summary>
 179     public enum CopyAndPasteMode
 180     {
 181         /// <summary>
 182         /// Copy & paste text with markup tag
 183         /// </summary>
 184         Markup,
 185
 186         /// <summary>
 187         /// Copy & paste text without item(image) tag
 188         /// </summary>
 189         NoImage,
 190
 191         /// <summary>
 192         /// Copy & paste text without markup tag
 193         /// </summary>
 194         PlainText
 195     }
 196
 197     /// <summary>
 198     /// Enumeration that defines the text format types.
 199     /// </summary>
 200     public enum TextFormat
 201     {
 202         /// <summary>
 203         /// Plain type
 204         /// </summary>
 205         Plain,
 206
 207         /// <summary>
 208         /// Markup type
 209         /// </summary>
 210         Markup
 211     }
 212
 213     /// <summary>
 214     /// Enumeration that defines the types of Input Hints.
 215     /// </summary>
 216     public enum InputHints
 217     {
 218         /// <summary>
 219         /// No active hints
 220         /// </summary>
 221         None,
 222
 223         /// <summary>
 224         /// suggest word auto completion
 225         /// </summary>
 226         AutoComplete,
 227
 228         /// <summary>
 229         /// typed text should not be stored.
 230         /// </summary>
 231         SensitiveData,
 232     }
 233
 234     /// <summary>
 235     /// Enumeration that defines the input panel (virtual keyboard) language modes.
 236     /// </summary>
 237     public enum InputPanelLanguage
 238     {
 239         /// <summary>
 240         /// Automatic language mode
 241         /// </summary>
 242         Automatic,
 243
 244         /// <summary>
 245         /// Alphabet language mode
 246         /// </summary>
 247         Alphabet,
 248     }
 249
 250     /// <summary>
 251     /// The entry is a convenience widget that shows a box in which the user can enter text.
 252     /// </summary>
 253     public class Entry : Layout
 254     {
 255         SmartEvent _clicked;
 256         SmartEvent _changedByUser;
 257         SmartEvent _cursorChanged;
 258         SmartEvent _activated;
 259
 260         Dictionary<Func<string, EvasObject>, Interop.Elementary.Elm_Entry_Item_Provider_Cb> _itemsProvider = new Dictionary<Func<string, EvasObject>, Interop.Elementary.Elm_Entry_Item_Provider_Cb>();
 261         Dictionary<Func<Entry, string, string>, Interop.Elementary.Elm_Entry_Filter_Cb> _textFilters = new Dictionary<Func<Entry, string, string>, Interop.Elementary.Elm_Entry_Filter_Cb>();
 262
 263         /// <summary>
 264         /// Creates and initializes a new instance of the Entry class.
 265         /// </summary>
 266         /// <param name="parent">The EvasObject to which the new Entry will be attached as a child.</param>
 267         public Entry(EvasObject parent) : base(parent)
 268         {
 269             _clicked = new SmartEvent(this, this.RealHandle, "clicked");
 270             _clicked.On += (s, e) => Clicked?.Invoke(this, EventArgs.Empty);
 271
 272             _changedByUser = new SmartEvent(this, this.RealHandle, "changed,user");
 273             _changedByUser.On += (s, e) => ChangedByUser?.Invoke(this, EventArgs.Empty);
 274
 275             _cursorChanged = new SmartEvent(this, this.RealHandle, "cursor,changed");
 276             _cursorChanged.On += (s, e) => CursorChanged?.Invoke(this, EventArgs.Empty);
 277
 278             _activated = new SmartEvent(this, this.RealHandle, "activated");
 279             _activated.On += (s, e) => Activated?.Invoke(this, EventArgs.Empty);
 280         }
 281
 282         /// <summary>
 283         /// Activated will be triggered when the entry in Activated stated.
 284         /// </summary>
 285         public event EventHandler Activated;
 286
 287         /// <summary>
 288         /// Clicked will be triggered when the entry is clicked.
 289         /// </summary>
 290         public event EventHandler Clicked;
 291
 292         /// <summary>
 293         /// ChangedByUser will be triggered when the entry changed by user.
 294         /// </summary>
 295         public event EventHandler ChangedByUser;
 296
 297         /// <summary>
 298         /// CursorChanged will be triggered when the Cursor in the entry is changed.
 299         /// </summary>
 300         public event EventHandler CursorChanged;
 301
 302         /// <summary>
 303         /// Sets or gets the entry to the single line mode.
 304         /// </summary>
 305         public bool IsSingleLine
 306         {
 307             get
 308             {
 309                 return Interop.Elementary.elm_entry_single_line_get(RealHandle);
 310             }
 311             set
 312             {
 313                 Interop.Elementary.elm_entry_single_line_set(RealHandle, value);
 314             }
 315         }
 316
 317         /// <summary>
 318         /// Sets or gets the entry to the password mode.
 319         /// </summary>
 320         public bool IsPassword
 321         {
 322             get
 323             {
 324                 return Interop.Elementary.elm_entry_password_get(RealHandle);
 325             }
 326             set
 327             {
 328                 Interop.Elementary.elm_entry_password_set(RealHandle, value);
 329             }
 330         }
 331
 332         /// <summary>
 333         /// Sets or gets whether the entry is editable.
 334         /// </summary>
 335         public bool IsEditable
 336         {
 337             get
 338             {
 339                 return Interop.Elementary.elm_entry_editable_get(RealHandle);
 340             }
 341             set
 342             {
 343                 Interop.Elementary.elm_entry_editable_set(RealHandle, value);
 344             }
 345         }
 346
 347         /// <summary>
 348         /// Sets or gets whether the entry is empty.
 349         /// </summary>
 350         public bool IsEmpty
 351         {
 352             get
 353             {
 354                 return Interop.Elementary.elm_entry_is_empty(RealHandle);
 355             }
 356         }
 357
 358         /// <summary>
 359         /// Sets or gets text currently shown in the object entry.
 360         /// </summary>
 361         public override string Text
 362         {
 363             get
 364             {
 365                 return Interop.Elementary.elm_entry_entry_get(RealHandle);
 366             }
 367             set
 368             {
 369                 Interop.Elementary.elm_entry_entry_set(RealHandle, value);
 370             }
 371         }
 372
 373         /// <summary>
 374         /// Sets or gets the style on the top of the user style stack.
 375         /// </summary>
 376         /// <remarks>If there is styles in the user style stack, the properties in the top style of user style stack will replace the properties in current theme. The input style is specified in format tag='property=value' (i.e. DEFAULT='font=Sans font_size=60'hilight=' + font_weight=Bold').</remarks>
 377         public string TextStyle
 378         {
 379             get
 380             {
 381                 return Interop.Elementary.elm_entry_text_style_user_peek(RealHandle);
 382             }
 383             set
 384             {
 385                 Interop.Elementary.elm_entry_text_style_user_push(RealHandle, value);
 386             }
 387         }
 388
 389         /// <summary>
 390         /// Sets or gets the current position of the cursor in the entry.
 391         /// </summary>
 392         public int CursorPosition
 393         {
 394             get
 395             {
 396                 return Interop.Elementary.elm_entry_cursor_pos_get(RealHandle);
 397             }
 398             set
 399             {
 400                 Interop.Elementary.elm_entry_cursor_pos_set(RealHandle, value);
 401             }
 402         }
 403
 404         /// <summary>
 405         /// Sets or gets the scrollable state of the entry.
 406         /// </summary>
 407         public bool Scrollable
 408         {
 409             get
 410             {
 411                 return Interop.Elementary.elm_entry_scrollable_get(RealHandle);
 412             }
 413             set
 414             {
 415                 // HACK: Enabling the scrollable property of an entry causes its internal
 416                 //       hierarchy to change, making the internal edje object inaccessible.
 417                 //       Access it before the property is set, to cache the edje object's handle.
 418                 if (value)
 419                 {
 420                     var dummy = EdjeObject;
 421                 }
 422                 Interop.Elementary.elm_entry_scrollable_set(RealHandle, value);
 423             }
 424         }
 425
 426         /// <summary>
 427         /// Sets or Gets the autocapitalization type on the immodule.
 428         /// </summary>
 429         public AutoCapital AutoCapital
 430         {
 431             get
 432             {
 433                 return (AutoCapital)Interop.Elementary.elm_entry_autocapital_type_get(RealHandle);
 434             }
 435             set
 436             {
 437                 Interop.Elementary.elm_entry_autocapital_type_set(RealHandle, (Interop.Elementary.AutocapitalType)value);
 438             }
 439         }
 440
 441         /// <summary>
 442         /// Sets or Gets the entry object's 'autosave' status.
 443         /// </summary>
 444         public bool IsAutoSave
 445         {
 446             get
 447             {
 448                 return Interop.Elementary.elm_entry_autosave_get(RealHandle);
 449             }
 450             set
 451             {
 452                 Interop.Elementary.elm_entry_autosave_set(RealHandle, value);
 453             }
 454         }
 455
 456         /// <summary>
 457         /// Sets or Gets entry text paste/drop mode.
 458         /// </summary>
 459         public CopyAndPasteMode CopyAndPasteMode
 460         {
 461             get
 462             {
 463                 return (CopyAndPasteMode)Interop.Elementary.elm_entry_cnp_mode_get(RealHandle);
 464             }
 465             set
 466             {
 467                 Interop.Elementary.elm_entry_cnp_mode_set(RealHandle, (Interop.Elementary.CopyAndPasteMode)value);
 468             }
 469         }
 470
 471         /// <summary>
 472         /// Gets the geometry of the cursor.
 473         /// </summary>
 474         public Rect CursorGeometry
 475         {
 476             get
 477             {
 478                 int x, y, w, h;
 479                 Interop.Elementary.elm_entry_cursor_geometry_get(RealHandle, out x, out y, out w, out h);
 480                 return new Rect(x, y, w, h);
 481             }
 482         }
 483
 484         /// <summary>
 485         /// Gets whether a format node exists at the current cursor position.
 486         /// </summary>
 487         public bool IsCursorFormat
 488         {
 489             get
 490             {
 491                 return Interop.Elementary.elm_entry_cursor_is_format_get(RealHandle);
 492             }
 493         }
 494
 495         /// <summary>
 496         /// Gets if the current cursor position holds a visible format node.
 497         /// </summary>
 498         public bool IsCursorVisibelFormat
 499         {
 500             get
 501             {
 502                 return Interop.Elementary.elm_entry_cursor_is_visible_format_get(RealHandle);
 503             }
 504         }
 505
 506         /// <summary>
 507         /// Sets or Gets the value of input hint.
 508         /// </summary>
 509         public InputHints InputHint
 510         {
 511             get
 512             {
 513                 return (InputHints)Interop.Elementary.elm_entry_input_hint_get(RealHandle);
 514             }
 515             set
 516             {
 517                 Interop.Elementary.elm_entry_input_hint_set(RealHandle, (Interop.Elementary.InputHints)value);
 518             }
 519         }
 520
 521         /// <summary>
 522         ///  Sets or gets the language mode of the input panel.
 523         /// </summary>
 524         public InputPanelLanguage InputPanelLanguage
 525         {
 526             get
 527             {
 528                 return (InputPanelLanguage)Interop.Elementary.elm_entry_input_panel_language_get(RealHandle);
 529             }
 530             set
 531             {
 532                 Interop.Elementary.elm_entry_input_panel_language_set(RealHandle, (Interop.Elementary.InputPanelLanguage)value);
 533             }
 534         }
 535
 536         /// <summary>
 537         /// Sets or gets the input panel layout variation of the entry.
 538         /// </summary>
 539         public int InputPanelVariation
 540         {
 541             get
 542             {
 543                 return Interop.Elementary.elm_entry_input_panel_layout_variation_get(RealHandle);
 544             }
 545             set
 546             {
 547                 Interop.Elementary.elm_entry_input_panel_layout_variation_set(RealHandle, value);
 548             }
 549         }
 550
 551         /// <summary>
 552         /// Sets or gets the line wrap type to use on multi-line entries.
 553         /// </summary>
 554         public WrapType LineWrapType
 555         {
 556             get
 557             {
 558                 return (WrapType)Interop.Elementary.elm_entry_line_wrap_get(RealHandle);
 559             }
 560             set
 561             {
 562                 Interop.Elementary.elm_entry_line_wrap_set(RealHandle, (Interop.Elementary.WrapType)value);
 563             }
 564         }
 565
 566         /// <summary>
 567         /// Sets or gets whether the entry should allow to use the text prediction.
 568         /// </summary>
 569         public bool PredictionAllowed
 570         {
 571             get
 572             {
 573                 return Interop.Elementary.elm_entry_prediction_allow_get(RealHandle);
 574             }
 575             set
 576             {
 577                 Interop.Elementary.elm_entry_prediction_allow_set(RealHandle, value);
 578             }
 579         }
 580
 581         /// <summary>
 582         /// Sets or gets whether the return key on the input panel should be disabled or not.
 583         /// </summary>
 584         public bool InputPanelReturnKeyDisabled
 585         {
 586             get
 587             {
 588                 return Interop.Elementary.elm_entry_input_panel_return_key_disabled_get(RealHandle);
 589             }
 590             set
 591             {
 592                 Interop.Elementary.elm_entry_input_panel_return_key_disabled_set(RealHandle, value);
 593             }
 594         }
 595
 596         /// <summary>
 597         /// Sets or gets the attribute to show the input panel in case of only an user's explicit Mouse Up event.
 598         /// It doesn't request to show the input panel even though it has focus.
 599         /// If true, the input panel will be shown in case of only Mouse up event. (Focus event will be ignored.)
 600         /// </summary>
 601         public bool InputPanelShowByOnDemand
 602         {
 603             get
 604             {
 605                 return Interop.Elementary.elm_entry_input_panel_show_on_demand_get(RealHandle);
 606             }
 607             set
 608             {
 609                 Interop.Elementary.elm_entry_input_panel_show_on_demand_set(RealHandle, value);
 610             }
 611         }
 612
 613         /// <summary>
 614         /// Sets the file (and implicitly loads it) for the text to display and then edit.
 615         /// </summary>
 616         /// <param name="file">The path to the file to load and save</param>
 617         /// <param name="textFormat">The file format</param>
 618         public void SetFile(string file, TextFormat textFormat)
 619         {
 620             Interop.Elementary.elm_entry_file_set(RealHandle, file, (Interop.Elementary.TextFormat)textFormat);
 621         }
 622
 623         /// <summary>
 624         /// Converts a markup (HTML-like) string into UTF-8.
 625         /// </summary>
 626         /// <param name="markup">The string (in markup) to be converted</param>
 627         /// <returns>The converted string (in UTF-8) </returns>
 628         public static string ConvertMarkupToUtf8(string markup)
 629         {
 630             return Interop.Elementary.elm_entry_markup_to_utf8(markup);
 631         }
 632
 633         /// <summary>
 634         /// Moves the cursor by one position to the right within the entry.
 635         /// </summary>
 636         /// <returns></returns>
 637         public bool MoveCursorNext()
 638         {
 639             return Interop.Elementary.elm_entry_cursor_next(RealHandle);
 640         }
 641
 642         /// <summary>
 643         /// Moves the cursor one place to the left within the entry.
 644         /// </summary>
 645         /// <returns>TRUE on success, otherwise FALSE on failure</returns>
 646         public bool MoveCursorPrev()
 647         {
 648             return Interop.Elementary.elm_entry_cursor_prev(RealHandle);
 649         }
 650
 651         /// <summary>
 652         /// Moves the cursor one line up within the entry.
 653         /// </summary>
 654         /// <returns>TRUE on success, otherwise FALSE on failure</returns>
 655         public bool MoveCursorUp()
 656         {
 657             return Interop.Elementary.elm_entry_cursor_up(RealHandle);
 658         }
 659
 660         /// <summary>
 661         /// Moves the cursor one line down within the entry.
 662         /// </summary>
 663         /// <returns>TRUE on success, otherwise FALSE on failure</returns>
 664         public bool MoveCursorDown()
 665         {
 666             return Interop.Elementary.elm_entry_cursor_down(RealHandle);
 667         }
 668
 669         /// <summary>
 670         /// Moves the cursor to the beginning of the entry.
 671         /// </summary>
 672         public void MoveCursorBegin()
 673         {
 674             Interop.Elementary.elm_entry_cursor_begin_set(RealHandle);
 675         }
 676
 677         /// <summary>
 678         /// Moves the cursor to the end of the entry.
 679         /// </summary>
 680         public void MoveCursorEnd()
 681         {
 682             Interop.Elementary.elm_entry_cursor_end_set(RealHandle);
 683         }
 684
 685         /// <summary>
 686         /// Moves the cursor to the beginning of the current line.
 687         /// </summary>
 688         public void MoveCursorLineBegin()
 689         {
 690             Interop.Elementary.elm_entry_cursor_line_begin_set(RealHandle);
 691         }
 692
 693         /// <summary>
 694         /// Moves the cursor to the end of the current line.
 695         /// </summary>
 696         public void MoveCursorLineEnd()
 697         {
 698             Interop.Elementary.elm_entry_cursor_line_end_set(RealHandle);
 699         }
 700
 701         /// <summary>
 702         /// Sets the input panel layout of the entry.
 703         /// </summary>
 704         /// <param name="layout">The layout type</param>
 705         public void SetInputPanelLayout(InputPanelLayout layout)
 706         {
 707             Interop.Elementary.elm_entry_input_panel_layout_set(RealHandle, (Interop.Elementary.InputPanelLayout)layout);
 708         }
 709
 710         /// <summary>
 711         /// Sets the attribute to show the input panel automatically.
 712         /// </summary>
 713         /// <param name="enabled">If true the input panel appears when the entry is clicked or has focus, otherwise false</param>
 714         public void SetInputPanelEnabled(bool enabled)
 715         {
 716             Interop.Elementary.elm_entry_input_panel_enabled_set(RealHandle, enabled);
 717         }
 718
 719         /// <summary>
 720         /// Sets the "return" key type. This type is used to set the string or icon on the "return" key of the input panel.
 721         /// </summary>
 722         /// <param name="keyType">The type of "return" key on the input panel</param>
 723         public void SetInputPanelReturnKeyType(InputPanelReturnKeyType keyType)
 724         {
 725             Interop.Elementary.elm_entry_input_panel_return_key_type_set(RealHandle, (Interop.Elementary.ReturnKeyType)keyType);
 726         }
 727
 728         /// <summary>
 729         /// Hides the input panel (virtual keyboard).
 730         /// </summary>
 731         /// <remark>
 732         /// Note that the input panel is shown or hidden automatically according to the focus state of the entry widget.
 733         /// This API can be used in case of manually controlling by using SetInputPanelEnabled(false).
 734         /// </remark>
 735         public void HideInputPanel()
 736         {
 737             Interop.Elementary.elm_entry_input_panel_hide(RealHandle);
 738         }
 739
 740         /// <summary>
 741         /// Selects all the text within the entry.
 742         /// </summary>
 743         public void SelectAll()
 744         {
 745             Interop.Elementary.elm_entry_select_all(RealHandle);
 746         }
 747
 748         /// <summary>
 749         /// Drops any existing text selection within the entry.
 750         /// </summary>
 751         public void SelectNone()
 752         {
 753             Interop.Elementary.elm_entry_select_none(RealHandle);
 754         }
 755
 756         /// <summary>
 757         /// Sets the color of color class for a given widget.
 758         /// </summary>
 759         /// <param name="part">The name of color class.</param>
 760         /// <param name="color">The struct of color</param>
 761         public override void SetPartColor(string part, Color color)
 762         {
 763             IntPtr handle = (part == "bg") ? Handle : RealHandle;
 764             Interop.Elementary.elm_object_color_class_color_set(handle, part, color.R * color.A / 255,
 765                                                                                 color.G * color.A / 255,
 766                                                                                 color.B * color.A / 255,
 767                                                                                 color.A);
 768         }
 769
 770         /// <summary>
 771         /// Forces calculation of the entry size and text layouting.
 772         /// </summary>
 773         public void ForceCalculation()
 774         {
 775             Interop.Elementary.elm_entry_calc_force(RealHandle);
 776         }
 777
 778         /// <summary>
 779         /// Gets the string by the cursor at its current position.
 780         /// </summary>
 781         /// <returns></returns>
 782         public string GetCursorContent()
 783         {
 784             return Interop.Elementary.elm_entry_cursor_content_get(RealHandle);
 785         }
 786
 787         /// <summary>
 788         /// Begins a selection within the entry as though the user were holding down the mouse button to make a selection.
 789         /// </summary>
 790         public void BeginCursorSelection()
 791         {
 792             Interop.Elementary.elm_entry_cursor_selection_begin(RealHandle);
 793         }
 794
 795         /// <summary>
 796         /// Appends the text of the entry.
 797         /// </summary>
 798         /// <param name="text">The text to be displayed</param>
 799         public void AppendText(string text)
 800         {
 801             Interop.Elementary.elm_entry_entry_append(RealHandle, text);
 802         }
 803
 804         /// <summary>
 805         /// Inserts the given text into the entry at the current cursor position.
 806         /// </summary>
 807         /// <param name="text"></param>
 808         public void InsertTextToCursor(string text)
 809         {
 810             Interop.Elementary.elm_entry_entry_insert(RealHandle, text);
 811         }
 812
 813         /// <summary>
 814         /// Ends a selection within the entry as though the user had just released the mouse button while making a selection.
 815         /// </summary>
 816         public void EndCursorSelection()
 817         {
 818             Interop.Elementary.elm_entry_cursor_selection_end(RealHandle);
 819         }
 820
 821         /// <summary>
 822         /// Writes any changes made to the file that is set by File.
 823         /// </summary>
 824         public void SaveFile()
 825         {
 826             Interop.Elementary.elm_entry_file_save(RealHandle);
 827         }
 828
 829         /// <summary>
 830         /// Show the input panel (virtual keyboard) based on the input panel property of entry such as layout, autocapital types, and so on.
 831         /// </summary>
 832         /// <remarks>
 833         /// Note that input panel is shown or hidden automatically according to the focus state of entry widget.
 834         /// This API can be used in the case of manually controlling by using SetInputPanelEnabled(false).
 835         /// </remarks>
 836         public void ShowInputPanel()
 837         {
 838             Interop.Elementary.elm_entry_input_panel_show(RealHandle);
 839         }
 840
 841         /// <summary>
 842         /// This appends a custom item provider to the list for that entry.
 843         /// </summary>
 844         /// <param name="func">This function is used to provide items.</param>
 845         public void AppendItemProvider(Func<string, EvasObject> func)
 846         {
 847             if (func != null)
 848             {
 849                 if (!_itemsProvider.ContainsKey(func))
 850                 {
 851                     Interop.Elementary.Elm_Entry_Item_Provider_Cb itemProviderCallback;
 852
 853                     itemProviderCallback = (d, o, t) =>
 854                     {
 855                         return func?.Invoke(t);
 856                     };
 857                     Interop.Elementary.elm_entry_item_provider_append(RealHandle, itemProviderCallback, IntPtr.Zero);
 858                     _itemsProvider.Add(func, itemProviderCallback);
 859                 }
 860             }
 861         }
 862
 863         /// <summary>
 864         /// This prepends a custom item provider to the list for that entry.
 865         /// </summary>
 866         /// <param name="func">This function is used to provide items.</param>
 867         public void PrependItemProvider(Func<string, EvasObject> func)
 868         {
 869             if (!_itemsProvider.ContainsKey(func))
 870             {
 871                 Interop.Elementary.Elm_Entry_Item_Provider_Cb itemProviderCallback;
 872
 873                 itemProviderCallback = (d, o, t) =>
 874                 {
 875                     return func?.Invoke(t);
 876                 };
 877                 Interop.Elementary.elm_entry_item_provider_prepend(RealHandle, itemProviderCallback, IntPtr.Zero);
 878                 _itemsProvider.Add(func, itemProviderCallback);
 879             }
 880         }
 881
 882         /// <summary>
 883         /// This removes a custom item provider to the list for that entry.
 884         /// </summary>
 885         /// <param name="itemProvider">This function is used to provide items.</param>
 886         public void RemoveItemProvider(Func<string, EvasObject> func)
 887         {
 888             if (_itemsProvider.ContainsKey(func))
 889             {
 890                 Interop.Elementary.Elm_Entry_Item_Provider_Cb itemProviderCallback;
 891                 _itemsProvider.TryGetValue(func, out itemProviderCallback);
 892
 893                 Interop.Elementary.elm_entry_item_provider_remove(RealHandle, itemProviderCallback, IntPtr.Zero);
 894                 _itemsProvider.Remove(func);
 895             }
 896         }
 897
 898         /// <summary>
 899         /// Append a markup filter function for text inserted in the entry.
 900         /// </summary>
 901         /// <param name="filter">This function type is used by entry filters to modify text.</param>
 902         public void AppendMarkUpFilter(Func<Entry, string, string> filter)
 903         {
 904             if (!_textFilters.ContainsKey(filter))
 905             {
 906                 Interop.Elementary.Elm_Entry_Filter_Cb textFilterCallback = (IntPtr d, IntPtr e, ref IntPtr t) =>
 907                 {
 908                     var text = Marshal.PtrToStringAnsi(t);
 909
 910                     var updateText = filter(this, text);
 911
 912                     if (updateText != text)
 913                     {
 914                         Interop.Libc.Free(t);
 915                         t = Marshal.StringToHGlobalAnsi(updateText);
 916                     }
 917                 };
 918                 Interop.Elementary.elm_entry_markup_filter_append(RealHandle, textFilterCallback, IntPtr.Zero);
 919                 _textFilters.Add(filter, textFilterCallback);
 920             }
 921         }
 922
 923         /// <summary>
 924         /// Prepend a markup filter function for text inserted in the entry.
 925         /// </summary>
 926         /// <param name="filter">This function type is used by entry filters to modify text.</param>
 927         public void PrependMarkUpFilter(Func<Entry, string, string> filter)
 928         {
 929             if (!_textFilters.ContainsKey(filter))
 930             {
 931                 Interop.Elementary.Elm_Entry_Filter_Cb textFilterCallback = (IntPtr d, IntPtr e, ref IntPtr t) =>
 932                 {
 933                     var text = Marshal.PtrToStringAnsi(t);
 934
 935                     var updateText = filter(this, text);
 936
 937                     if (updateText != text)
 938                     {
 939                         Interop.Libc.Free(t);
 940                         t = Marshal.StringToHGlobalAnsi(updateText);
 941                     }
 942                 };
 943                 Interop.Elementary.elm_entry_markup_filter_prepend(RealHandle, textFilterCallback, IntPtr.Zero);
 944                 _textFilters.Add(filter, textFilterCallback);
 945             }
 946         }
 947
 948         /// <summary>
 949         /// Remove a markup filter
 950         /// </summary>
 951         /// <param name="filter">This function type is used by entry filters to modify text.</param>
 952         public void RemoveMarkUpFilter(Func<Entry, string, string> filter)
 953         {
 954             if (_textFilters.ContainsKey(filter))
 955             {
 956                 Interop.Elementary.Elm_Entry_Filter_Cb textFilterCallback;
 957                 _textFilters.TryGetValue(filter, out textFilterCallback);
 958
 959                 Interop.Elementary.elm_entry_markup_filter_remove(RealHandle, textFilterCallback, IntPtr.Zero);
 960                 _textFilters.Remove(filter);
 961             }
 962         }
 963
 964         /// <summary>
 965         /// This executes a "copy" action on the selected text in the entry.
 966         /// </summary>
 967         public void CopySelection()
 968         {
 969             Interop.Elementary.elm_entry_selection_copy(RealHandle);
 970         }
 971
 972         /// <summary>
 973         /// This executes a "cut" action on the selected text in the entry.
 974         /// </summary>
 975         public void CutSelection()
 976         {
 977             Interop.Elementary.elm_entry_selection_cut(RealHandle);
 978         }
 979
 980         /// <summary>
 981         /// This executes a "paste" action in the entry.
 982         /// </summary>
 983         public void PasteSelection()
 984         {
 985             Interop.Elementary.elm_entry_selection_paste(RealHandle);
 986         }
 987
 988         /// <summary>
 989         /// This disabled the entry's selection.
 990         /// </summary>
 991         /// <param name="disable">If true, the selection are disabled.</param>
 992         public void DisableSelection(bool disable)
 993         {
 994             Interop.Elementary.elm_entry_selection_handler_disabled_set(RealHandle, disable);
 995         }
 996
 997         /// <summary>
 998         /// Get any selected text within the entry.
 999         /// </summary>
1000         /// <returns>Selection's value</returns>
1001         public string GetSelection()
1002         {
1003             return Interop.Elementary.elm_entry_selection_get(RealHandle);
1004         }
1005
1006         /// <summary>
1007         /// This selects a region of text within the entry.
1008         /// </summary>
1009         /// <param name="start">The starting position.</param>
1010         /// <param name="end">The end position.</param>
1011         public void SetSelectionRegion(int start, int end)
1012         {
1013             Interop.Elementary.elm_entry_select_region_set(RealHandle, start, end);
1014         }
1015
1016         /// <summary>
1017         /// Sets the visibility of the left-side widget of the entry
1018         /// </summary>
1019         /// <param name="isDisplay">true if the object should be displayed, false if not.</param>
1020         public void SetIconVisible(bool isDisplay)
1021         {
1022             Interop.Elementary.elm_entry_icon_visible_set(RealHandle, isDisplay);
1023         }
1024
1025         /// <summary>
1026         /// Set whether the return key on the input panel is disabled automatically when entry has no text.
1027         /// </summary>
1028         /// <param name="enable">If enabled is true, the return key is automatically disabled when the entry has no text.</param>
1029         public void SetInputPanelReturnKeyAutoEnable(bool enable)
1030         {
1031             Interop.Elementary.elm_entry_input_panel_return_key_autoenabled_set(RealHandle, enable);
1032         }
1033
1034         protected override IntPtr CreateHandle(EvasObject parent)
1035         {
1036             IntPtr handle = Interop.Elementary.elm_layout_add(parent.Handle);
1037             Interop.Elementary.elm_layout_theme_set(handle, "layout", "background", "default");
1038
1039             RealHandle = Interop.Elementary.elm_entry_add(handle);
1040             Interop.Elementary.elm_object_part_content_set(handle, "elm.swallow.content", RealHandle);
1041
1042             return handle;
1043         }
1044     }
1045 }