internals/src/EflSharp/EflSharp/Circle/RotarySelector.cs

   1 using System;
   2 using System.Collections.Generic;
   3 using System.Text;
   4
   5 namespace Efl
   6 {
   7     namespace Ui
   8     {
   9         namespace Wearable
  10         {
  11
  12             /// <summary>
  13             /// The event argument of Rotary Selector.
  14             /// </summary>
  15             /// <since_tizen> 6 </since_tizen>
  16             public class RotarySelectorItemEventArgs : EventArgs
  17             {
  18                 public RotarySelectorItem item { get; set; }
  19             }
  20
  21             /// <summary>
  22             /// The event argument of Rotary Selector Reorder.
  23             /// </summary>
  24             /// <since_tizen> 6 </since_tizen>
  25             public class RotarySelectorItemReorderedEventArgs : RotarySelectorItemEventArgs
  26             {
  27                 public int NewIndex { get; internal set; }
  28
  29                 public int OldIndex { get; internal set; }
  30             }
  31
  32             /// <summary>
  33             /// The event argument of Rotary Selector editing state.
  34             /// </summary>
  35             /// <since_tizen> 6 </since_tizen>
  36             public class RotarySelectorEditingEventArgs : EventArgs
  37             {
  38                 public bool editing { get; internal set; }
  39             }
  40
  41             /// <summary>
  42             /// The RotarySelector is a widget to display a selector and multiple items surrounding the selector.
  43             /// An item can be selected by the Rotary event or user item click.
  44             /// </summary>
  45             /// <since_tizen> 6 </since_tizen>
  46             public class RotarySelector : Efl.Ui.Layout
  47             {
  48                 const string IconPartName = "selector,icon";
  49                 const string ContentPartName = "selector,content";
  50                 const string BgPartName = "selector,bg_image";
  51
  52                 const string ItemSelectedEventName = "item,selected";
  53                 const string ItemClickedEventName = "item,clicked";
  54                 const string ItemDeletedEventName = "item,deleted";
  55                 const string ItemReorderedEventName = "item,reordered";
  56                 const string EditingEnterEventName = "editing,entered";
  57                 const string EditingLeaveEventName = "editing,exited";
  58
  59                 Image _normalBgImage;
  60
  61                 readonly List<RotarySelectorItem> Items = new List<RotarySelectorItem>();
  62
  63                 /// <summary>
  64                 /// Clicked will be triggered when selecting again the already selected item or selecting a selector.
  65                 /// </summary>
  66                 /// <since_tizen> 6 </since_tizen>
  67                 public event EventHandler<RotarySelectorItemEventArgs> ClickedEvt;
  68
  69                 /// <summary>
  70                 /// Selected will be triggered when selecting an item.
  71                 /// </summary>
  72                 /// <since_tizen> 6 </since_tizen>
  73                 public event EventHandler<RotarySelectorItemEventArgs> SelectedEvt;
  74
  75                 /// <summary>
  76                 /// Triggered when the user deleted the item
  77                 /// </summary>
  78                 /// <since_tizen> 6 </since_tizen>
  79                 public event EventHandler<RotarySelectorItemEventArgs> Deleted;
  80
  81                 /// <summary>
  82                 /// Triggered when the user reordered the item
  83                 /// </summary>
  84                 /// <since_tizen> 6 </since_tizen>
  85                 public event EventHandler<RotarySelectorItemReorderedEventArgs> Reordered;
  86
  87                 /// <summary>
  88                 /// Editing will be triggered when entering and leaving the editing state.
  89                 /// </summary>
  90                 /// <since_tizen> 6 </since_tizen>
  91                 public event EventHandler<RotarySelectorEditingEventArgs> EditingStateChanged;
  92
  93                 private Interop.Evas.SmartCallback smartClicked;
  94                 private Interop.Evas.SmartCallback smartSelected;
  95                 private Interop.Evas.SmartCallback smartDeleted;
  96                 private Interop.Evas.SmartCallback smartReordered;
  97                 private Interop.Evas.SmartCallback smartEditingEnter;
  98                 private Interop.Evas.SmartCallback smartEditingLeave;
  99
 100                 /// <summary>
 101                 /// Creates and initializes a new instance of the RotarySelector class.
 102                 /// </summary>
 103                 /// <param name="parent">The Efl.Ui.Widget to which the new RotarySelector will be attached as a child.</param>
 104                 /// <since_tizen> 6 </since_tizen>
 105                 public RotarySelector(Efl.Ui.Widget parent) : base(new Efl.Eo.Globals.WrappingHandle(Interop.Eext.eext_rotary_selector_add(parent.NativeHandle)))
 106                 {
 107                     smartClicked = new Interop.Evas.SmartCallback((d, o, e) =>
 108                     {
 109                         RotarySelectorItem clickedItem = FindItemByNativeHandle(e);
 110                         if (clickedItem != null)
 111                             ClickedEvt?.Invoke(this, new RotarySelectorItemEventArgs { item = clickedItem});
 112                     });
 113
 114                     smartSelected = new Interop.Evas.SmartCallback((d, o, e) =>
 115                     {
 116                         RotarySelectorItem selectedItem = FindItemByNativeHandle(e);
 117                         if (selectedItem != null)
 118                             SelectedEvt?.Invoke(this, new RotarySelectorItemEventArgs { item = selectedItem });
 119                     });
 120
 121                     smartDeleted = new Interop.Evas.SmartCallback((d, o, e) =>
 122                     {
 123                         RotarySelectorItem deletedItem = FindItemByNativeHandle(e);
 124                         if (deletedItem != null)
 125                             Deleted?.Invoke(this, new RotarySelectorItemEventArgs { item = deletedItem });
 126                         Items.Remove(deletedItem);
 127                     });
 128
 129                     smartReordered = new Interop.Evas.SmartCallback((d, o, e) =>
 130                     {
 131                         var items_list = Interop.Eext.eext_rotary_selector_items_get(this.NativeHandle);
 132                         int idx = Eina.ListNativeFunctions.eina_list_data_idx(items_list, e);
 133                         RotarySelectorItem reorderedItem = FindItemByNativeHandle(e);
 134                         if (reorderedItem != null)
 135                             Reordered?.Invoke(this, new RotarySelectorItemReorderedEventArgs
 136                             { item = reorderedItem, OldIndex = Items.IndexOf(reorderedItem), NewIndex = idx });
 137                         UpdateListOrder(reorderedItem, idx);
 138                     });
 139
 140                     smartEditingEnter = new Interop.Evas.SmartCallback((d, o, e) =>
 141                     {
 142                         EditingStateChanged?.Invoke(this, new RotarySelectorEditingEventArgs { editing = true});
 143                     });
 144
 145                     smartEditingLeave = new Interop.Evas.SmartCallback((d, o, e) =>
 146                     {
 147                         EditingStateChanged?.Invoke(this, new RotarySelectorEditingEventArgs { editing = false });
 148                     });
 149
 150                     Interop.Evas.evas_object_smart_callback_add(this.NativeHandle, ItemClickedEventName, smartClicked, IntPtr.Zero);
 151                     Interop.Evas.evas_object_smart_callback_add(this.NativeHandle, ItemSelectedEventName, smartSelected, IntPtr.Zero);
 152                     Interop.Evas.evas_object_smart_callback_add(this.NativeHandle, ItemDeletedEventName, smartDeleted, IntPtr.Zero);
 153                     Interop.Evas.evas_object_smart_callback_add(this.NativeHandle, ItemReorderedEventName, smartReordered, IntPtr.Zero);
 154                     Interop.Evas.evas_object_smart_callback_add(this.NativeHandle, EditingEnterEventName, smartEditingEnter, IntPtr.Zero);
 155                     Interop.Evas.evas_object_smart_callback_add(this.NativeHandle, EditingLeaveEventName, smartEditingLeave, IntPtr.Zero);
 156                 }
 157
 158                 private void UpdateListOrder(RotarySelectorItem reorderedItem, int currentIdx)
 159                 {
 160                     Items.Remove(reorderedItem);
 161                     Items.Insert(currentIdx, reorderedItem);
 162                 }
 163
 164                 private RotarySelectorItem FindItemByNativeHandle(IntPtr handle)
 165                 {
 166                     foreach(RotarySelectorItem item in Items)
 167                     {
 168                         if (item.NativeHandle == handle)
 169                             return item;
 170                     }
 171
 172                     return null;
 173                 }
 174
 175                 /// <summary>
 176                 /// Sets or gets the edit mode of rotary selector.
 177                 /// </summary>
 178                 /// <since_tizen> 6 </since_tizen>
 179                 public bool EditMode
 180                 {
 181                     get
 182                     {
 183                         return Interop.Eext.eext_rotary_selector_editing_enabled_get(this.NativeHandle);
 184                     }
 185                     set
 186                     {
 187                         Interop.Eext.eext_rotary_selector_editing_enabled_set(this.NativeHandle, value);
 188                     }
 189                 }
 190
 191                 /// <summary>
 192                 /// Sets or gets the add item mode of rotary selector.
 193                 /// </summary>
 194                 /// <since_tizen> 6 </since_tizen>
 195                 public bool AddItemMode
 196                 {
 197                     get
 198                     {
 199                         return Interop.Eext.eext_rotary_selector_add_item_enabled_get(this.NativeHandle);
 200                     }
 201                     set
 202                     {
 203                         Interop.Eext.eext_rotary_selector_add_item_enabled_set(this.NativeHandle, value);
 204                     }
 205                 }
 206
 207                 /// <summary>
 208                 /// Appends a rotary selector item.
 209                 /// </summary>
 210                 /// <since_tizen> 6 </since_tizen>
 211                 public void Append(RotarySelectorItem item)
 212                 {
 213                     if (item.NativeHandle != null)
 214                     {
 215                         Items.Add(item);
 216                         item.NativeHandle = Interop.Eext.eext_rotary_selector_item_append(this.NativeHandle);
 217                     }
 218                 }
 219
 220                 /// <summary>
 221                 /// Prepends a rotary selector item.
 222                 /// </summary>
 223                 /// <since_tizen> 6 </since_tizen>
 224                 public void Prepend(RotarySelectorItem item)
 225                 {
 226                     if (item.NativeHandle != null)
 227                     {
 228                         Items.Insert(0, item);
 229                         item.NativeHandle = Interop.Eext.eext_rotary_selector_item_prepend(this.NativeHandle);
 230                     }
 231                 }
 232
 233                 /// <summary>
 234                 /// Inserts a rotary selector item after the target item.
 235                 /// </summary>
 236                 /// <since_tizen> 6 </since_tizen>
 237                 public void InsertAfter(RotarySelectorItem targetItem, RotarySelectorItem item)
 238                 {
 239                     if (item.NativeHandle != null && targetItem != null)
 240                     {
 241                         if (!Items.Contains(targetItem)) return;
 242                         Items.Insert(Items.IndexOf(targetItem) + 1, item);
 243                         item.NativeHandle = Interop.Eext.eext_rotary_selector_item_insert_after(this.NativeHandle, targetItem.NativeHandle);
 244                     }
 245                 }
 246
 247                 /// <summary>
 248                 /// Inserts a rotary selector item before the target item.
 249                 /// </summary>
 250                 /// <since_tizen> 6 </since_tizen>
 251                 public void InsertBefore(RotarySelectorItem targetItem, RotarySelectorItem item)
 252                 {
 253                     if (item.NativeHandle != null && targetItem != null)
 254                     {
 255                         if (!Items.Contains(targetItem)) return;
 256                         Items.Insert(Items.IndexOf(targetItem), item);
 257                         item.NativeHandle = Interop.Eext.eext_rotary_selector_item_insert_before(this.NativeHandle, targetItem.NativeHandle);
 258                     }
 259                 }
 260
 261                 /// <summary>
 262                 /// Delete a rotary selector item.
 263                 /// </summary>
 264                 /// <since_tizen> 6 </since_tizen>
 265                 public void DeleteItem(RotarySelectorItem item)
 266                 {
 267                     if (item.NativeHandle != null)
 268                     {
 269                         if (!Items.Contains(item)) return;
 270                         Items.Remove(item);
 271                         Interop.Eext.eext_rotary_selector_item_del(item.NativeHandle);
 272                     }
 273                 }
 274
 275                 /// <summary>
 276                 /// Clears all items of rotary selector.
 277                 /// </summary>
 278                 /// <since_tizen> 6 </since_tizen>
 279                 public void ClearItems()
 280                 {
 281                     if (this.NativeHandle != null)
 282                     {
 283                         Items.Clear();
 284                         Interop.Eext.eext_rotary_selector_items_clear(this.NativeHandle);
 285                     }
 286                 }
 287
 288                 /// <summary>
 289                 /// Sets or gets the selected item of a rotary selector object.
 290                 /// </summary>
 291                 /// <since_tizen> 6 </since_tizen>
 292                 public RotarySelectorItem SelectedItem
 293                 {
 294                     get
 295                     {
 296                         IntPtr nativeHandle = Interop.Eext.eext_rotary_selector_selected_item_get(this.NativeHandle);
 297                         RotarySelectorItem item = FindItemByNativeHandle(nativeHandle);
 298                         return item;
 299                     }
 300                     set
 301                     {
 302                         Interop.Eext.eext_rotary_selector_selected_item_set(this.NativeHandle, value.NativeHandle);
 303                     }
 304                 }
 305
 306                 void SetPart(string partName, State state, Image img)
 307                 {
 308                     if (img != null)
 309                         Interop.Eext.eext_rotary_selector_part_content_set(this.NativeHandle, partName, (int)state, img.NativeHandle);
 310                 }
 311
 312                 /// <summary>
 313                 /// Sets or gets the background image of a rotary selector object.
 314                 /// </summary>
 315                 /// <since_tizen> 6 </since_tizen>
 316                 public Image BackgroundImage
 317                 {
 318                     get
 319                     {
 320                         return _normalBgImage;
 321                     }
 322                     set
 323                     {
 324                         _normalBgImage = value;
 325                         SetPart(BgPartName, State.Normal, value);
 326                     }
 327                 }
 328
 329                 internal enum State
 330                 {
 331                     Normal,
 332                     Pressed
 333                 }
 334             }
 335         }
 336     }
 337 }