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 RotarySelector is a widget to display a selector and multiple items surrounding the selector.
  23             /// An item can be selected by the Rotary event or user item click.
  24             /// </summary>
  25             /// <since_tizen> 6 </since_tizen>
  26             public class RotarySelector : Efl.Ui.Layout
  27             {
  28                 const string IconPartName = "selector,icon";
  29                 const string ContentPartName = "selector,content";
  30                 const string BgPartName = "selector,bg_image";
  31
  32                 const string ItemSelectedEventName = "item,selected";
  33                 const string ItemClickedEventName = "item,clicked";
  34
  35                 Image _normalBgImage;
  36
  37                 readonly List<RotarySelectorItem> Items = new List<RotarySelectorItem>();
  38
  39                 /// <summary>
  40                 /// Clicked will be triggered when selecting again the already selected item or selecting a selector.
  41                 /// </summary>
  42                 /// <since_tizen> 6 </since_tizen>
  43                 public event EventHandler<RotarySelectorItemEventArgs> Clicked;
  44
  45                 /// <summary>
  46                 /// Selected will be triggered when selecting an item.
  47                 /// </summary>
  48                 /// <since_tizen> 6 </since_tizen>
  49                 public event EventHandler<RotarySelectorItemEventArgs> Selected;
  50
  51                 private Interop.Evas.SmartCallback smartClicked;
  52                 private Interop.Evas.SmartCallback smartSelected;
  53
  54                 /// <summary>
  55                 /// Creates and initializes a new instance of the RotarySelector class.
  56                 /// </summary>
  57                 /// <param name="parent">The Efl.Ui.Widget to which the new RotarySelector will be attached as a child.</param>
  58                 /// <since_tizen> 6 </since_tizen>
  59                 public RotarySelector(Efl.Ui.Widget parent) : base(Interop.Eext.eext_rotary_selector_add(parent.NativeHandle))
  60                 {
  61                     smartClicked = new Interop.Evas.SmartCallback((d, o, e) =>
  62                     {
  63                         RotarySelectorItem clickedItem = FindItemByNativeHandle(e);
  64                         if (clickedItem != null)
  65                             Clicked?.Invoke(this, new RotarySelectorItemEventArgs { item = clickedItem});
  66                     });
  67
  68                     smartSelected = new Interop.Evas.SmartCallback((d, o, e) =>
  69                     {
  70                         RotarySelectorItem selectedItem = FindItemByNativeHandle(e);
  71                         if (selectedItem != null)
  72                             Selected.Invoke(this, new RotarySelectorItemEventArgs { item = selectedItem });
  73                     });
  74
  75                     Interop.Evas.evas_object_smart_callback_add(this.NativeHandle, ItemClickedEventName, smartClicked, IntPtr.Zero);
  76                     Interop.Evas.evas_object_smart_callback_add(this.NativeHandle, ItemSelectedEventName, smartSelected, IntPtr.Zero);
  77                 }
  78
  79                 private RotarySelectorItem FindItemByNativeHandle(IntPtr handle)
  80                 {
  81                     foreach(RotarySelectorItem item in Items)
  82                     {
  83                         if (item.NativeHandle == handle)
  84                             return item;
  85                     }
  86
  87                     return null;
  88                 }
  89
  90                 /// <summary>
  91                 /// Sets or gets the edit mode of rotary selector.
  92                 /// </summary>
  93                 /// <since_tizen> 6 </since_tizen>
  94                 public bool EditMode
  95                 {
  96                     get
  97                     {
  98                         return Interop.Eext.eext_rotary_selector_editing_enabled_get(this.NativeHandle);
  99                     }
 100                     set
 101                     {
 102                         Interop.Eext.eext_rotary_selector_editing_enabled_set(this.NativeHandle, value);
 103                     }
 104                 }
 105
 106                 /// <summary>
 107                 /// Sets or gets the add item mode of rotary selector.
 108                 /// </summary>
 109                 /// <since_tizen> 6 </since_tizen>
 110                 public bool AddItemMode
 111                 {
 112                     get
 113                     {
 114                         return Interop.Eext.eext_rotary_selector_add_item_enabled_get(this.NativeHandle);
 115                     }
 116                     set
 117                     {
 118                         Interop.Eext.eext_rotary_selector_add_item_enabled_set(this.NativeHandle, value);
 119                     }
 120                 }
 121
 122                 /// <summary>
 123                 /// Appends a rotary selector item.
 124                 /// </summary>
 125                 /// <since_tizen> 6 </since_tizen>
 126                 public void Append(RotarySelectorItem item)
 127                 {
 128                     if (item.NativeHandle != null)
 129                     {
 130                         Items.Add(item);
 131                         item.NativeHandle = Interop.Eext.eext_rotary_selector_item_append(this.NativeHandle);
 132                     }
 133                 }
 134
 135                 /// <summary>
 136                 /// Prepends a rotary selector item.
 137                 /// </summary>
 138                 /// <since_tizen> 6 </since_tizen>
 139                 public void Prepend(RotarySelectorItem item)
 140                 {
 141                     if (item.NativeHandle != null)
 142                     {
 143                         Items.Insert(0, item);
 144                         item.NativeHandle = Interop.Eext.eext_rotary_selector_item_prepend(this.NativeHandle);
 145                     }
 146                 }
 147
 148                 /// <summary>
 149                 /// Inserts a rotary selector item after the target item.
 150                 /// </summary>
 151                 /// <since_tizen> 6 </since_tizen>
 152                 public void InsertAfter(RotarySelectorItem targetItem, RotarySelectorItem item)
 153                 {
 154                     if (item.NativeHandle != null && targetItem != null)
 155                     {
 156                         if (!Items.Contains(targetItem)) return;
 157                         Items.Insert(Items.IndexOf(targetItem) + 1, item);
 158                         item.NativeHandle = Interop.Eext.eext_rotary_selector_item_insert_after(this.NativeHandle, targetItem.NativeHandle);
 159                     }
 160                 }
 161
 162                 /// <summary>
 163                 /// Inserts a rotary selector item before the target item.
 164                 /// </summary>
 165                 /// <since_tizen> 6 </since_tizen>
 166                 public void InsertBefore(RotarySelectorItem targetItem, RotarySelectorItem item)
 167                 {
 168                     if (item.NativeHandle != null && targetItem != null)
 169                     {
 170                         if (!Items.Contains(targetItem)) return;
 171                         Items.Insert(Items.IndexOf(targetItem), item);
 172                         item.NativeHandle = Interop.Eext.eext_rotary_selector_item_insert_before(this.NativeHandle, targetItem.NativeHandle);
 173                     }
 174                 }
 175
 176                 /// <summary>
 177                 /// Delete a rotary selector item.
 178                 /// </summary>
 179                 /// <since_tizen> 6 </since_tizen>
 180                 public void DeleteItem(RotarySelectorItem item)
 181                 {
 182                     if (item.NativeHandle != null)
 183                     {
 184                         if (!Items.Contains(item)) return;
 185                         Items.Remove(item);
 186                         Interop.Eext.eext_rotary_selector_item_del(item.NativeHandle);
 187                     }
 188                 }
 189
 190                 /// <summary>
 191                 /// Clears all items of rotary selector.
 192                 /// </summary>
 193                 /// <since_tizen> 6 </since_tizen>
 194                 public void ClearItems()
 195                 {
 196                     if (this.NativeHandle != null)
 197                     {
 198                         Items.Clear();
 199                         Interop.Eext.eext_rotary_selector_items_clear(this.NativeHandle);
 200                     }
 201                 }
 202
 203                 /// <summary>
 204                 /// Sets or gets the selected item of a rotary selector object.
 205                 /// </summary>
 206                 /// <since_tizen> 6 </since_tizen>
 207                 public RotarySelectorItem SelectedItem
 208                 {
 209                     get
 210                     {
 211                         IntPtr nativeHandle = Interop.Eext.eext_rotary_selector_selected_item_get(this.NativeHandle);
 212                         RotarySelectorItem item = FindItemByNativeHandle(nativeHandle);
 213                         return item;
 214                     }
 215                     set
 216                     {
 217                         Interop.Eext.eext_rotary_selector_selected_item_set(this.NativeHandle, value.NativeHandle);
 218                     }
 219                 }
 220
 221                 void SetPart(string partName, State state, Image img)
 222                 {
 223                     if (img != null)
 224                         Interop.Eext.eext_rotary_selector_part_content_set(this.NativeHandle, partName, (int)state, img.NativeHandle);
 225                 }
 226
 227                 /// <summary>
 228                 /// Sets or gets the background image of a rotary selector object.
 229                 /// </summary>
 230                 /// <since_tizen> 6 </since_tizen>
 231                 public Image BackgroundImage
 232                 {
 233                     get
 234                     {
 235                         return _normalBgImage;
 236                     }
 237                     set
 238                     {
 239                         _normalBgImage = value;
 240                         SetPart(BgPartName, State.Normal, value);
 241                     }
 242                 }
 243
 244                 internal enum State
 245                 {
 246                     Normal,
 247                     Pressed
 248                 }
 249             }
 250         }
 251     }
 252 }