src/ElmSharp/ElmSharp/GenList.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
  20 namespace ElmSharp
  21 {
  22     /// <summary>
  23     /// Enumeration for setting genlist item type.
  24     /// </summary>
  25     public enum GenListItemType
  26     {
  27         /// <summary>
  28         /// if Normal is set then this item is normal item.
  29         /// </summary>
  30         Normal = 0,
  31
  32         /// <summary>
  33         /// If tree is set then this item is displayed as an item that is able to expand and have child items.
  34         /// </summary>
  35         Tree = (1 << 0),
  36
  37         /// <summary>
  38         /// if Group is set then this item is group index item that is displayed at the top until the next group comes.
  39         /// </summary>
  40         Group = (1 << 1),
  41     }
  42
  43     /// <summary>
  44     /// Enumeration for setting genlist's resizing behavior, transverse axis scrolling and items cropping.
  45     /// </summary>
  46     public enum GenListMode
  47     {
  48         /// <summary>
  49         /// The genlist won't set any of its size hints to inform how a possible container should resize it.
  50         /// Then, if it's not created as a "resize object", it might end with zeroed dimensions.
  51         /// The genlist will respect the container's geometry and, if any of its items won't fit into its transverse axis, one won't be able to scroll it in that direction.
  52         /// </summary>
  53         Compress = 0,
  54
  55         /// <summary>
  56         /// This is the same as Compress, with the exception that if any of its items won't fit into its transverse axis, one will be able to scroll it in that direction.
  57         /// </summary>
  58         Scroll,
  59
  60         /// <summary>
  61         /// Sets a minimum size hint on the genlist object, so that containers may respect it (and resize itself to fit the child properly).
  62         /// More specifically, a minimum size hint will be set for its transverse axis, so that the largest item in that direction fits well.
  63         /// This is naturally bound by the genlist object's maximum size hints, set externally.
  64         /// </summary>
  65         Limit,
  66
  67         /// <summary>
  68         /// Besides setting a minimum size on the transverse axis, just like on Limit, the genlist will set a minimum size on th longitudinal axis, trying to reserve space to all its children to be visible at a time.
  69         /// This is naturally bound by the genlist object's maximum size hints, set externally.
  70         /// </summary>
  71         Expand
  72     }
  73
  74     /// <summary>
  75     /// It inherits System.EventArgs.
  76     /// It contains Item which is <see cref="GenListItem"/> type.
  77     /// All events of GenList contain GenListItemEventArgs as a parameter.
  78     /// </summary>
  79     public class GenListItemEventArgs : EventArgs
  80     {
  81         /// <summary>
  82         /// Gets or sets GenList item. The return type is <see cref="GenListItem"/>.
  83         /// </summary>
  84         public GenListItem Item { get; set; }
  85
  86         internal static GenListItemEventArgs CreateFromSmartEvent(IntPtr data, IntPtr obj, IntPtr info)
  87         {
  88             GenListItem item = ItemObject.GetItemByHandle(info) as GenListItem;
  89             return new GenListItemEventArgs() { Item = item };
  90         }
  91     }
  92
  93     /// <summary>
  94     /// Enumeration that defines where to position the item in the genlist.
  95     /// </summary>
  96     public enum ScrollToPosition
  97     {
  98         /// <summary>
  99         /// Scrolls to nowhere.
 100         /// </summary>
 101         None = 0,
 102
 103         /// <summary>
 104         /// Scrolls to the nearest viewport.
 105         /// </summary>
 106         In = (1 << 0),
 107
 108         /// <summary>
 109         /// Scrolls to the top of the viewport.
 110         /// </summary>
 111         Top = (1 << 1),
 112
 113         /// <summary>
 114         /// Scrolls to the middle of the viewport.
 115         /// </summary>
 116         Middle = (1 << 2),
 117
 118         /// <summary>
 119         /// Scrolls to the bottom of the viewport.
 120         /// </summary>
 121         Bottom = (1 << 3)
 122     }
 123
 124     /// <summary>
 125     /// It inherits <see cref="Layout"/>.
 126     /// The GenList is a widget that aims to have more expansive list than the simple <see cref="List"/> in ElmSharp that could have more flexible items and allow many more entries while still being fast and low on memory usage.
 127     /// At the same time it was also made to be able to do tree structures.
 128     /// But the price to pay is more complexity when it comes to usage.
 129     /// If all you want is a simple list with icons and a single text, use the <see cref="List"/> widget.
 130     /// </summary>
 131     public class GenList : Layout
 132     {
 133         HashSet<GenListItem> _children = new HashSet<GenListItem>();
 134
 135         SmartEvent<GenListItemEventArgs> _selected;
 136         SmartEvent<GenListItemEventArgs> _unselected;
 137         SmartEvent<GenListItemEventArgs> _activated;
 138         SmartEvent<GenListItemEventArgs> _pressed;
 139         SmartEvent<GenListItemEventArgs> _released;
 140         SmartEvent<GenListItemEventArgs> _doubleClicked;
 141         SmartEvent<GenListItemEventArgs> _expanded;
 142         SmartEvent<GenListItemEventArgs> _realized;
 143         SmartEvent<GenListItemEventArgs> _unrealized;
 144         SmartEvent<GenListItemEventArgs> _longpressed;
 145         SmartEvent<GenListItemEventArgs> _moved;
 146         SmartEvent<GenListItemEventArgs> _movedAfter;
 147         SmartEvent<GenListItemEventArgs> _movedBefore;
 148         SmartEvent _scrollAnimationStarted;
 149         SmartEvent _scrollAnimationStopped;
 150         SmartEvent _changed;
 151
 152         /// <summary>
 153         /// Creates and initializes a new instance of the GenList class.
 154         /// </summary>
 155         /// <param name="parent">The parent is a given container which will be attached by GenList as a child. It's <see cref="EvasObject"/> type.</param>
 156         public GenList(EvasObject parent) : base(parent)
 157         {
 158             ListMode = GenListMode.Compress;
 159             InitializeSmartEvent();
 160         }
 161
 162         /// <summary>
 163         /// Gets or sets whether the homogeneous mode is enabled.
 164         /// </summary>
 165         /// <remarks>
 166         /// If true, the genlist items have same height and width.
 167         /// </remarks>
 168         public bool Homogeneous
 169         {
 170             get
 171             {
 172                 return Interop.Elementary.elm_genlist_homogeneous_get(RealHandle);
 173             }
 174             set
 175             {
 176                 Interop.Elementary.elm_genlist_homogeneous_set(RealHandle, value);
 177             }
 178         }
 179
 180         /// <summary>
 181         /// Gets or sets the horizontal stretching mode. This mode used for sizing items horizontally.
 182         /// The default value is <see cref="GenListMode.Scroll"/> which means that if items are too wide to fit, the scroller scrolls horizontally.
 183         /// If set <see cref="GenListMode.Compress"/> which means that the item width is fixed (restricted to a minimum of) to the list width when calculating its size in order to allow the height to be calculated based on it.
 184         /// If set <see cref="GenListMode.Limit"/> which means that items are expanded to the viewport width and limited to that size.
 185         /// if set <see cref="GenListMode.Expand"/> which means that genlist try to reserve space to all its items to be visible at a time.
 186         /// </summary>
 187         /// <remarks>
 188         /// Compress makes genlist resize slower as it recalculates every item height again whenever the list width changes.
 189         /// The homogeneous mode is so that all items in the genlist are of the same width/height. With Compress, genlist items are initialized fast.
 190         /// However, there are no sub-objects in the genlist which can be on the flying resizable (such as TEXTBLOCK).
 191         /// If so, then some dynamic resizable objects in the genlist would not be diplayed properly.
 192         /// </remarks>
 193         public GenListMode ListMode
 194         {
 195             get
 196             {
 197                 return (GenListMode)Interop.Elementary.elm_genlist_mode_get(RealHandle);
 198             }
 199             set
 200             {
 201                 Interop.Elementary.elm_genlist_mode_set(RealHandle, (int)value);
 202             }
 203         }
 204
 205         /// <summary>
 206         /// Gets the first item in the genlist.
 207         /// </summary>
 208         public GenListItem FirstItem
 209         {
 210             get
 211             {
 212                 IntPtr handle = Interop.Elementary.elm_genlist_first_item_get(RealHandle);
 213                 return ItemObject.GetItemByHandle(handle) as GenListItem;
 214             }
 215         }
 216
 217         /// <summary>
 218         /// Gets the last item in the genlist.
 219         /// </summary>
 220         public GenListItem LastItem
 221         {
 222             get
 223             {
 224                 IntPtr handle = Interop.Elementary.elm_genlist_last_item_get(RealHandle);
 225                 return ItemObject.GetItemByHandle(handle) as GenListItem;
 226             }
 227         }
 228
 229         /// <summary>
 230         /// Gets or sets the reorder mode.
 231         /// After turning on the reorder mode, longpress on a normal item triggers reordering of the item.
 232         /// You can move the item up and down. However, reordering does not work with group items.
 233         /// </summary>
 234         public bool ReorderMode
 235         {
 236             get
 237             {
 238                 return Interop.Elementary.elm_genlist_reorder_mode_get(RealHandle);
 239             }
 240             set
 241             {
 242                 Interop.Elementary.elm_genlist_reorder_mode_set(RealHandle, value);
 243             }
 244         }
 245
 246         /// <summary>
 247         /// Gets or set the maximum number of items within an item block.
 248         /// </summary>
 249         public int BlockCount
 250         {
 251             get
 252             {
 253                 return Interop.Elementary.elm_genlist_block_count_get(RealHandle);
 254             }
 255             set
 256             {
 257                 Interop.Elementary.elm_genlist_block_count_set(RealHandle, value);
 258             }
 259         }
 260
 261         /// <summary>
 262         /// Gets or sets whether the genlist items should be highlighted when an item is selected.
 263         /// </summary>
 264         public bool IsHighlight
 265         {
 266             get
 267             {
 268                 return Interop.Elementary.elm_genlist_highlight_mode_get(RealHandle);
 269             }
 270             set
 271             {
 272                 Interop.Elementary.elm_genlist_highlight_mode_set(RealHandle, value);
 273             }
 274         }
 275
 276         /// <summary>
 277         /// Gets or sets the timeout in seconds for the longpress event.
 278         /// </summary>
 279         public double LongPressTimeout
 280         {
 281             get
 282             {
 283                 return Interop.Elementary.elm_genlist_longpress_timeout_get(RealHandle);
 284             }
 285             set
 286             {
 287                 Interop.Elementary.elm_genlist_longpress_timeout_set(RealHandle, value);
 288             }
 289         }
 290
 291         /// <summary>
 292         /// Gets or sets whether enable multi-selection in the genlist.
 293         /// </summary>
 294         public bool IsMultiSelection
 295         {
 296             get
 297             {
 298                 return Interop.Elementary.elm_genlist_multi_select_get(RealHandle);
 299             }
 300             set
 301             {
 302                 Interop.Elementary.elm_genlist_multi_select_set(RealHandle, value);
 303             }
 304         }
 305
 306         /// <summary>
 307         /// Gets the selected item in a given genlist widget.
 308         /// </summary>
 309         public GenListItem SelectedItem
 310         {
 311             get
 312             {
 313                 IntPtr handle = Interop.Elementary.elm_genlist_selected_item_get(RealHandle);
 314                 return ItemObject.GetItemByHandle(handle) as GenListItem;
 315             }
 316         }
 317
 318         /// <summary>
 319         /// Gets or sets the genlist select mode by <see cref="GenItemSelectionMode"/>.
 320         /// </summary>
 321         public GenItemSelectionMode SelectionMode
 322         {
 323             get
 324             {
 325                 return (GenItemSelectionMode)Interop.Elementary.elm_genlist_select_mode_get(RealHandle);
 326             }
 327             set
 328             {
 329                 Interop.Elementary.elm_genlist_select_mode_set(RealHandle, (int)value);
 330             }
 331         }
 332
 333         /// <summary>
 334         /// ItemSelected is raised when a new genlist item is selected.
 335         /// </summary>
 336         public event EventHandler<GenListItemEventArgs> ItemSelected;
 337
 338         /// <summary>
 339         /// ItemUnselected is raised when the genlist item is Unselected.
 340         /// </summary>
 341         public event EventHandler<GenListItemEventArgs> ItemUnselected;
 342
 343         /// <summary>
 344         /// ItemPressed is raised when a new genlist item is pressed.
 345         /// </summary>
 346         public event EventHandler<GenListItemEventArgs> ItemPressed;
 347
 348         /// <summary>
 349         /// ItemReleased is raised when a new genlist item is released.
 350         /// </summary>
 351         public event EventHandler<GenListItemEventArgs> ItemReleased;
 352
 353         /// <summary>
 354         /// ItemActivated is raised when a new genlist item is double clicked or pressed (enter|return|spacebar).
 355         /// </summary>
 356         public event EventHandler<GenListItemEventArgs> ItemActivated;
 357
 358         /// <summary>
 359         /// ItemDoubleClicked is raised when a new genlist item is double clicked.
 360         /// </summary>
 361         public event EventHandler<GenListItemEventArgs> ItemDoubleClicked;
 362
 363         /// <summary>
 364         /// ItemExpanded is raised when a new genlist item is indicated to expand.
 365         /// </summary>
 366         public event EventHandler<GenListItemEventArgs> ItemExpanded;
 367
 368         /// <summary>
 369         /// ItemRealized is raised when a new genlist item is created as a real object.
 370         /// </summary>
 371         public event EventHandler<GenListItemEventArgs> ItemRealized;
 372
 373         /// <summary>
 374         /// ItemUnrealized is raised when a new genlist item is unrealized.
 375         /// After calling unrealize, the item's content objects are deleted and the item object itself is deleted or is put into a floating cache.
 376         /// </summary>
 377         public event EventHandler<GenListItemEventArgs> ItemUnrealized;
 378
 379         /// <summary>
 380         /// ItemLongPressed is raised when a genlist item is pressed for a certain amount of time. By default it's 1 second.
 381         /// </summary>
 382         public event EventHandler<GenListItemEventArgs> ItemLongPressed;
 383
 384         /// <summary>
 385         /// ItemMoved is raised when a genlist item is moved in the reorder mode.
 386         /// </summary>
 387         public event EventHandler<GenListItemEventArgs> ItemMoved;
 388
 389         /// <summary>
 390         /// ItemMovedAfter is raised when a genlist item is moved after another item in the reorder mode.
 391         /// To get the relative previous item, use <see cref="GenListItem.Previous"/>.
 392         /// </summary>
 393         public event EventHandler<GenListItemEventArgs> ItemMovedAfter;
 394
 395         /// <summary>
 396         /// ItemMovedBefore is raised when a genlist item is moved before another item in the reorder mode.
 397         /// To get the relative next item, use <see cref="GenListItem.Next"/>.
 398         /// </summary>
 399         public event EventHandler<GenListItemEventArgs> ItemMovedBefore;
 400
 401         /// <summary>
 402         /// Changed is raised when genlist is changed.
 403         /// </summary>
 404         public event EventHandler Changed
 405         {
 406             add { _changed.On += value; }
 407             remove { _changed.On -= value; }
 408         }
 409
 410         /// <summary>
 411         /// ScrollAnimationStarted is raised when scrolling animation has started.
 412         /// </summary>
 413         public event EventHandler ScrollAnimationStarted
 414         {
 415             add { _scrollAnimationStarted.On += value; }
 416             remove { _scrollAnimationStarted.On -= value; }
 417         }
 418
 419         /// <summary>
 420         /// ScrollAnimationStopped is raised when scrolling animation has stopped.
 421         /// </summary>
 422         public event EventHandler ScrollAnimationStopped
 423         {
 424             add { _scrollAnimationStopped.On += value; }
 425             remove { _scrollAnimationStopped.On -= value; }
 426         }
 427
 428         /// <summary>
 429         /// Appends a new item to the end of a given genlist widget.
 430         /// </summary>
 431         /// <param name="itemClass">The itemClass defines how to display the data.</param>
 432         /// <param name="data">The item data.</param>
 433         /// <returns>Return a new added genlist item that contains data and itemClass.</returns>
 434         /// <seealso cref="GenItemClass"/>
 435         /// <seealso cref="GenListItem"/>
 436         public GenListItem Append(GenItemClass itemClass, object data)
 437         {
 438             return Append(itemClass, data, GenListItemType.Normal);
 439         }
 440
 441         /// <summary>
 442         /// Appends a new item with <see cref="GenListItemType"/> to the end of a given genlist widget.
 443         /// </summary>
 444         /// <param name="itemClass">The itemClass defines how to display the data.</param>
 445         /// <param name="data">The item data.</param>
 446         /// <param name="type">The genlist item type.</param>
 447         /// <returns>Return a new added genlist item that contains data and itemClass.</returns>
 448         public GenListItem Append(GenItemClass itemClass, object data, GenListItemType type)
 449         {
 450             return Append(itemClass, data, type, null);
 451         }
 452
 453         /// <summary>
 454         /// Appends a new item with <see cref="GenListItemType"/> to the end of a given genlist widget or the end of the children list if the parent is given.
 455         /// </summary>
 456         /// <param name="itemClass">The itemClass defines how to display the data.</param>
 457         /// <param name="data">The item data.</param>
 458         /// <param name="type">The genlist item type.</param>
 459         /// <param name="parent">The parent item, otherwise null if there is no parent item.</param>
 460         /// <returns>Return a new added genlist item that contains data and itemClass.</returns>
 461         public GenListItem Append(GenItemClass itemClass, object data, GenListItemType type, GenListItem parent)
 462         {
 463             GenListItem item = new GenListItem(data, itemClass);
 464             IntPtr handle = Interop.Elementary.elm_genlist_item_append(RealHandle, itemClass.UnmanagedPtr, (IntPtr)item.Id, parent, (int)type, null, (IntPtr)item.Id);
 465             item.Handle = handle;
 466             AddInternal(item);
 467             return item;
 468         }
 469
 470         /// <summary>
 471         /// Prepends a new item to the beginning of a given genlist widget.
 472         /// </summary>
 473         /// <param name="itemClass">The itemClass defines how to display the data.</param>
 474         /// <param name="data">The item data.</param>
 475         /// <returns>Return a new added genlist item that contains data and itemClass.</returns>
 476         public GenListItem Prepend(GenItemClass itemClass, object data)
 477         {
 478             return Prepend(itemClass, data, GenListItemType.Normal);
 479         }
 480
 481         /// <summary>
 482         /// Prepends a new item with <see cref="GenListItemType"/> to the beginning of a given genlist widget.
 483         /// </summary>
 484         /// <param name="itemClass">The itemClass defines how to display the data.</param>
 485         /// <param name="data">The item data.</param>
 486         /// <param name="type">The genlist item type.</param>
 487         /// <returns>Return a new added genlist item that contains data and itemClass.</returns>
 488         public GenListItem Prepend(GenItemClass itemClass, object data, GenListItemType type)
 489         {
 490             return Prepend(itemClass, data, type, null);
 491         }
 492
 493         /// <summary>
 494         /// Prepends a new item with <see cref="GenListItemType"/> to the beginning of a given genlist widget or the beginning of the children list if the parent is given.
 495         /// </summary>
 496         /// <param name="itemClass">The itemClass defines how to display the data.</param>
 497         /// <param name="data">The item data.</param>
 498         /// <param name="type">The genlist item type.</param>
 499         /// <param name="parent">The parent item, otherwise null if there is no parent item.</param>
 500         /// <returns>Return a new added genlist item that contains data and itemClass.</returns>
 501         public GenListItem Prepend(GenItemClass itemClass, object data, GenListItemType type, GenListItem parent)
 502         {
 503             GenListItem item = new GenListItem(data, itemClass);
 504             IntPtr handle = Interop.Elementary.elm_genlist_item_prepend(RealHandle, itemClass.UnmanagedPtr, (IntPtr)item.Id, parent, (int)type, null, (IntPtr)item.Id);
 505             item.Handle = handle;
 506             AddInternal(item);
 507             return item;
 508         }
 509
 510         /// <summary>
 511         /// Inserts an item before another item in a genlist widget.
 512         /// It is the same tree level or group as the item before which it is inserted.????
 513         /// </summary>
 514         /// <param name="itemClass">The itemClass defines how to display the data.</param>
 515         /// <param name="data">The item data.</param>
 516         /// <param name="before">The item before which to place this new one.</param>
 517         /// <returns>Return a new added genlist item that contains data and itemClass.</returns>
 518         public GenListItem InsertBefore(GenItemClass itemClass, object data, GenListItem before)
 519         {
 520             return InsertBefore(itemClass, data, before, GenListItemType.Normal);
 521         }
 522
 523         /// <summary>
 524         /// Inserts an item with <see cref="GenListItemType"/> before another item in a genlist widget.
 525         /// It is the same tree level or group as the item before which it is inserted.????
 526         /// </summary>
 527         /// <param name="itemClass">The itemClass defines how to display the data.</param>
 528         /// <param name="data">The item data.</param>
 529         /// <param name="before">The item before which to place this new one.</param>
 530         /// <param name="type">The genlist item type.</param>
 531         /// <returns>Return a new added genlist item that contains data and itemClass.</returns>
 532         public GenListItem InsertBefore(GenItemClass itemClass, object data, GenListItem before, GenListItemType type)
 533         {
 534             return InsertBefore(itemClass, data, before, type, null);
 535         }
 536
 537         /// <summary>
 538         /// Inserts an item with <see cref="GenListItemType"/> before another item under a parent in a genlist widget.
 539         /// </summary>
 540         /// <param name="itemClass">The itemClass defines how to display the data.</param>
 541         /// <param name="data">The item data.</param>
 542         /// <param name="before">The item before which to place this new one.</param>
 543         /// <param name="type">The genlist item type.</param>
 544         /// <param name="parent">The parent item, otherwise null if there is no parent item.</param>
 545         /// <returns>Return a new added genlist item that contains data and itemClass.</returns>
 546         public GenListItem InsertBefore(GenItemClass itemClass, object data, GenListItem before, GenListItemType type, GenListItem parent)
 547         {
 548             GenListItem item = new GenListItem(data, itemClass);
 549             // insert before the `before` list item
 550             IntPtr handle = Interop.Elementary.elm_genlist_item_insert_before(
 551                 RealHandle, // genlist handle
 552                 itemClass.UnmanagedPtr, // item class
 553                 (IntPtr)item.Id, // data
 554                 parent, // parent
 555                 before, // before
 556                 (int)type, // item type
 557                 null, // select callback
 558                 (IntPtr)item.Id); // callback data
 559             item.Handle = handle;
 560             AddInternal(item);
 561             return item;
 562         }
 563
 564         /// <summary>
 565         /// Inserts an item with <see cref="GenListItemType"/> after another item under a parent in a genlist widget.
 566         /// </summary>
 567         /// <param name="itemClass">The itemClass defines how to display the data.</param>
 568         /// <param name="data">The item data.</param>
 569         /// <param name="after">The item after which to place this new one.</param>
 570         /// <param name="type">The genlist item type.</param>
 571         /// <param name="parent">The parent item, otherwise null if there is no parent item.</param>
 572         /// <returns>Return a new added genlist item that contains data and itemClass.</returns>
 573         public GenListItem InsertAfter(GenItemClass itemClass, object data, GenListItem after, GenListItemType type, GenListItem parent)
 574         {
 575             GenListItem item = new GenListItem(data, itemClass);
 576             // insert before the `before` list item
 577             IntPtr handle = Interop.Elementary.elm_genlist_item_insert_before(
 578                 RealHandle, // genlist handle
 579                 itemClass.UnmanagedPtr, // item class
 580                 (IntPtr)item.Id, // data
 581                 parent, // parent
 582                 after, // after
 583                 (int)type, // item type
 584                 null, // select callback
 585                 (IntPtr)item.Id); // callback data
 586             item.Handle = handle;
 587             AddInternal(item);
 588             return item;
 589         }
 590
 591         /// <summary>
 592         /// Insert an item in a genlist widget using a user-defined sort function.
 593         /// </summary>
 594         /// <param name="itemClass">The itemClass defines how to display the data.</param>
 595         /// <param name="data">The item data.</param>
 596         /// <param name="comparison">User defined comparison function that defines the sort order based on genlist item and its data.</param>
 597         /// <param name="type">The genlist item type.</param>
 598         /// <param name="parent">The parent item, otherwise null if there is no parent item.</param>
 599         /// <returns>Return a genlist item that contains data and itemClass.</returns>
 600         public GenListItem InsertSorted(GenItemClass itemClass, object data, Comparison<object> comparison, GenListItemType type, GenListItem parent)
 601         {
 602             GenListItem item = new GenListItem(data, itemClass);
 603
 604             Interop.Elementary.Eina_Compare_Cb compareCallback = (handle1, handle2) =>
 605             {
 606                 GenListItem first = (ItemObject.GetItemByHandle(handle1) as GenListItem) ?? item;
 607                 GenListItem second = (ItemObject.GetItemByHandle(handle2) as GenListItem) ?? item;
 608                 return comparison(first.Data, second.Data);
 609             };
 610
 611             IntPtr handle = Interop.Elementary.elm_genlist_item_sorted_insert(
 612                 RealHandle, // genlist handle
 613                 itemClass.UnmanagedPtr, // item clas
 614                 (IntPtr)item.Id, // data
 615                 parent, // parent
 616                 (int)type, // item type
 617                 compareCallback, // compare callback
 618                 null, //select callback
 619                 (IntPtr)item.Id); // callback data
 620             item.Handle = handle;
 621             AddInternal(item);
 622             return item;
 623         }
 624
 625         /// <summary>
 626         /// Shows the given item with position type in a genlist.
 627         /// When animated is true, genlist will jump to the given item and display it (by animatedly scrolling), if it is not fully visible. This may use animation and may take some time.
 628         /// When animated is false, genlist will jump to the given item and display it (by jumping to that position), if it is not fully visible.
 629         /// </summary>
 630         /// <param name="item">The item to display.</param>
 631         /// <param name="position">The position to show the given item to <see cref="ScrollToPosition"/>.</param>
 632         /// <param name="animated">The animated indicates how to display the item, by scrolling or by jumping.</param>
 633         public void ScrollTo(GenListItem item, ScrollToPosition position, bool animated)
 634         {
 635             if (animated)
 636             {
 637                 Interop.Elementary.elm_genlist_item_bring_in(item.Handle, (Interop.Elementary.Elm_Genlist_Item_Scrollto_Type)position);
 638             }
 639             else
 640             {
 641                 Interop.Elementary.elm_genlist_item_show(item.Handle, (Interop.Elementary.Elm_Genlist_Item_Scrollto_Type)position);
 642             }
 643         }
 644
 645         /// <summary>
 646         /// Updates the content of all the realized items.
 647         /// This updates all the realized items by calling all the <see cref="GenItemClass"/> again to get the content, text and states.
 648         /// Use this when the original item data has changed and the changes are desired to reflect.
 649         /// To update just one item, use <see cref="GenListItem.Update"/>.
 650         /// </summary>
 651         /// <seealso cref="GenListItem.Update"/>
 652         public void UpdateRealizedItems()
 653         {
 654             Interop.Elementary.elm_genlist_realized_items_update(RealHandle);
 655         }
 656
 657         /// <summary>
 658         /// Removes all items from a given genlist widget.
 659         /// This removes (and deletes) all items in obj, making it empty.
 660         /// To delete just one item, use <see cref="ItemObject.Delete"/>.
 661         /// </summary>
 662         /// <seealso cref="ItemObject.Delete"/>
 663         public void Clear()
 664         {
 665             Interop.Elementary.elm_genlist_clear(RealHandle);
 666         }
 667
 668         /// <summary>
 669         /// Get the item that is at the x, y canvas coords.
 670         /// </summary>
 671         /// <param name="x">The input x coordinate</param>
 672         /// <param name="y">The input y coordinate</param>
 673         /// <param name="pos">The position relative to the item returned here
 674         ///  -1, 0, or 1, depending on whether the coordinate is on the upper portion of that item (-1), in the middle section (0), or on the lower part (1).
 675         /// </param>
 676         /// <returns></returns>
 677         public GenListItem GetItemByPosition(int x, int y, out int pos)
 678         {
 679             IntPtr handle = Interop.Elementary.elm_genlist_at_xy_item_get(RealHandle, x, y, out pos);
 680             return ItemObject.GetItemByHandle(handle) as GenListItem;
 681         }
 682
 683         /// <summary>
 684         /// Gets the nth item in a given genlist widget, placed at position nth, in its internal items list.
 685         /// </summary>
 686         /// <param name="index">The number of the item to grab (0 being the first)</param>
 687         /// <returns></returns>
 688         public GenListItem GetItemByIndex(int index)
 689         {
 690             IntPtr handle = Interop.Elementary.elm_genlist_nth_item_get(RealHandle, index);
 691             return ItemObject.GetItemByHandle(handle) as GenListItem;
 692         }
 693
 694         /// <summary>
 695         /// Creates a widget handle.
 696         /// </summary>
 697         /// <param name="parent">Parent EvasObject</param>
 698         /// <returns>Handle IntPtr</returns>
 699         protected override IntPtr CreateHandle(EvasObject parent)
 700         {
 701             IntPtr handle = Interop.Elementary.elm_layout_add(parent.Handle);
 702             Interop.Elementary.elm_layout_theme_set(handle, "layout", "elm_widget", "default");
 703
 704             RealHandle = Interop.Elementary.elm_genlist_add(handle);
 705             Interop.Elementary.elm_object_part_content_set(handle, "elm.swallow.content", RealHandle);
 706
 707             return handle;
 708         }
 709
 710         void InitializeSmartEvent()
 711         {
 712             _selected = new SmartEvent<GenListItemEventArgs>(this, this.RealHandle, "selected", GenListItemEventArgs.CreateFromSmartEvent);
 713             _unselected = new SmartEvent<GenListItemEventArgs>(this, this.RealHandle, "unselected", GenListItemEventArgs.CreateFromSmartEvent);
 714             _activated = new SmartEvent<GenListItemEventArgs>(this, this.RealHandle, "activated", GenListItemEventArgs.CreateFromSmartEvent);
 715             _pressed = new SmartEvent<GenListItemEventArgs>(this, this.RealHandle, "pressed", GenListItemEventArgs.CreateFromSmartEvent);
 716             _released = new SmartEvent<GenListItemEventArgs>(this, this.RealHandle, "released", GenListItemEventArgs.CreateFromSmartEvent);
 717             _doubleClicked = new SmartEvent<GenListItemEventArgs>(this, this.RealHandle, "clicked,double", GenListItemEventArgs.CreateFromSmartEvent);
 718             _expanded = new SmartEvent<GenListItemEventArgs>(this, this.RealHandle, "expanded", GenListItemEventArgs.CreateFromSmartEvent);
 719             _realized = new SmartEvent<GenListItemEventArgs>(this, this.RealHandle, "realized", GenListItemEventArgs.CreateFromSmartEvent);
 720             _unrealized = new SmartEvent<GenListItemEventArgs>(this, this.RealHandle, "unrealized", GenListItemEventArgs.CreateFromSmartEvent);
 721             _longpressed = new SmartEvent<GenListItemEventArgs>(this, this.RealHandle, "longpressed", GenListItemEventArgs.CreateFromSmartEvent);
 722             _moved = new SmartEvent<GenListItemEventArgs>(this, this.RealHandle, "moved", GenListItemEventArgs.CreateFromSmartEvent);
 723             _movedAfter = new SmartEvent<GenListItemEventArgs>(this, this.RealHandle, "moved,after", GenListItemEventArgs.CreateFromSmartEvent);
 724             _movedBefore = new SmartEvent<GenListItemEventArgs>(this, this.RealHandle, "moved,before", GenListItemEventArgs.CreateFromSmartEvent);
 725             _scrollAnimationStarted = new SmartEvent(this, this.RealHandle, "scroll,anim,start");
 726             _scrollAnimationStopped = new SmartEvent(this, this.RealHandle, "scroll,anim,stop");
 727             _changed = new SmartEvent(this, this.RealHandle, "changed");
 728
 729             _selected.On += (s, e) => { if (e.Item != null) ItemSelected?.Invoke(this, e); };
 730             _unselected.On += (s, e) => { if (e.Item != null) ItemUnselected?.Invoke(this, e); };
 731             _activated.On += (s, e) => { if (e.Item != null) ItemActivated?.Invoke(this, e); };
 732             _pressed.On += (s, e) => { if (e.Item != null) ItemPressed?.Invoke(this, e); };
 733             _released.On += (s, e) => { if (e.Item != null) ItemReleased?.Invoke(this, e); };
 734             _doubleClicked.On += (s, e) => { if (e.Item != null) ItemDoubleClicked?.Invoke(this, e); };
 735             _expanded.On += (s, e) => { if (e.Item != null) ItemExpanded?.Invoke(this, e); };
 736             _realized.On += (s, e) => { if (e.Item != null) ItemRealized?.Invoke(this, e); };
 737             _unrealized.On += (s, e) => { if (e.Item != null) ItemUnrealized?.Invoke(this, e); };
 738             _longpressed.On += (s, e) => { if (e.Item != null) ItemLongPressed?.Invoke(this, e); };
 739             _moved.On += (s, e) => { if (e.Item != null) ItemMoved?.Invoke(this, e); };
 740             _movedAfter.On += (s, e) => { if (e.Item != null) ItemMovedAfter?.Invoke(this, e); };
 741             _movedBefore.On += (s, e) => { if (e.Item != null) ItemMovedBefore?.Invoke(this, e); };
 742         }
 743
 744         void AddInternal(GenListItem item)
 745         {
 746             _children.Add(item);
 747             item.Deleted += Item_Deleted;
 748         }
 749
 750         void Item_Deleted(object sender, EventArgs e)
 751         {
 752             _children.Remove((GenListItem)sender);
 753         }
 754     }
 755 }