src/lib/elm_widget_item.eo

   1 //TIZEN_ONLY(20160527): widget: add AtspiAction interface to all widgets
   2 /*
   3 class Elm.Widget_Item(Eo.Base, Elm_Interface_Atspi_Accessible,
   4                       Elm_Interface_Atspi_Component)
   5 */
   6 class Elm.Widget_Item (Eo.Base, Elm_Interface_Atspi_Accessible,
   7          Elm_Interface_Atspi_Component, Elm_Interface_Atspi_Widget_Action)
   8 //
   9
  10 {
  11       eo_prefix: elm_wdg_item;
  12       legacy_prefix: elm_object_item;
  13       methods {
  14            @property tooltip_window_mode {
  15                 [[Control size restriction state of an object's tooltip
  16
  17                   This function returns whether a tooltip is allowed to expand beyond
  18                   its parent window's canvas.
  19                   It will instead be limited only by the size of the display.
  20
  21                   \@if MOBILE \@since_tizen 2.3
  22                   \@elseif WEARABLE \@since_tizen 2.3.1
  23                   \@endif
  24                 ]]
  25                 get {
  26                 }
  27                 set {
  28                      return: bool; [[$false on failure, $true on success]]
  29                 }
  30                 values {
  31                      disable: bool; [[If $true, size restrictions are disabled]]
  32                 }
  33            }
  34            @property tooltip_style {
  35                 [[Control a different style for this item tooltip.
  36
  37                   Note: before you set a style you should define a tooltip with
  38                   @.tooltip_content_cb_set or
  39                   @.tooltip_text_set
  40
  41                   See: elm_object_tooltip_style_set() for more details.
  42
  43                   \@if MOBILE \@since_tizen 2.3
  44                   \@elseif WEARABLE \@since_tizen 2.3.1
  45                   \@endif
  46                 ]]
  47                 get {
  48                 }
  49                 set {
  50                 }
  51                 values {
  52                      style: const (char)*; [[the theme style used/to use (default, transparent, ...)]]
  53                 }
  54            }
  55            @property cursor {
  56                 [[Control the type of mouse pointer/cursor decoration to be shown,
  57                   when the mouse pointer is over the given item
  58
  59                   This function works analogously as elm_object_cursor_set(), but
  60                   here the cursor's changing area is restricted to the item's
  61                   area, and not the whole widget's. Note that that item cursors
  62                   have precedence over widget cursors, so that a mouse over an
  63                   item with custom cursor set will always show that cursor.
  64
  65                   If this function is called twice for an object, a previously set
  66                   cursor will be unset on the second call.
  67
  68                   \@if MOBILE \@since_tizen 2.3
  69                   \@elseif WEARABLE \@since_tizen 2.3.1
  70                   \@endif
  71                 ]]
  72                 get {
  73                 }
  74                 set {
  75                 }
  76                 values {
  77                      cursor: const (char) *; [[the cursor type's name]]
  78                 }
  79            }
  80            @property cursor_style {
  81                 [[Conrol a different $style for a given custom cursor set for an item.
  82
  83                   This function only makes sense when one is using custom mouse
  84                   cursor decorations defined in a theme file, which can have,
  85                   given a cursor name/type, alternate styles on it. It
  86                   works analogously as elm_object_cursor_style_set(), but here
  87                   applies only to item objects.
  88
  89                   Warning: Before you set a cursor style you should have defined a
  90                   custom cursor previously on the item, with @.cursor.set
  91
  92                   \@if MOBILE \@since_tizen 2.3
  93                   \@elseif WEARABLE \@since_tizen 2.3.1
  94                   \@endif
  95                 ]]
  96                 get {
  97                 }
  98                 set {
  99                 }
 100                 values {
 101                      style: const (char) *; [[the theme style to use/in use (e.g. $"default", $"transparent", etc)]]
 102                 }
 103            }
 104            @property cursor_engine_only {
 105                 [[Control if the (custom)cursor for a given item should be
 106                   searched in its theme, also, or should only rely on the
 107                   rendering engine.
 108
 109                   Note: This call is of use only if you've set a custom cursor
 110                   for items, with @.cursor.set.
 111
 112                   Note: By default, cursors will only be looked for between those
 113                   provided by the rendering engine.
 114
 115                   \@if MOBILE \@since_tizen 2.3
 116                   \@elseif WEARABLE \@since_tizen 2.3.1
 117                   \@endif
 118                 ]]
 119                 get {
 120                 }
 121                 set {
 122                 }
 123                 values {
 124                      engine_only: bool; [[Use $true to have cursors looked for only on those provided by the rendering engine, $false to have them searched on the widget's theme, as well.]]
 125                 }
 126            }
 127            @property part_content {
 128                 [[Control a content of an object item
 129
 130                   This sets a new object to an item as a content object. If any object was
 131                   already set as a content object in the same part, previous object will be
 132                   deleted automatically.]]
 133                 get {
 134                 }
 135                 set {
 136                 }
 137                 keys {
 138                      part: const (char) * @nullable; [[The content part name  (NULL for the default content)]]
 139                 }
 140                 values {
 141                      content: Evas.Object *; [[The content of the object item]]
 142                 }
 143            }
 144            @property part_text {
 145                 [[Control a label of an object item
 146
 147                   Note: Elementary object items may have many labels]]
 148                 get {
 149                 }
 150                 set {
 151                 }
 152                 keys {
 153                      part: const (char) * @nullable; [[The text part name (NULL for the default label)]]
 154                 }
 155                 values {
 156                      label: const (char) *; [[Text of the label]]
 157                 }
 158            }
 159            @property part_text_custom @protected {
 160                 get {
 161                      [[Get additional text part content]]
 162                      legacy: null;
 163                 }
 164                 set {
 165                      [[Save additional text part content]]
 166                      legacy: null;
 167                 }
 168                 keys {
 169                      part: const (char) *;
 170                 }
 171                 values {
 172                      label: const (char) *;
 173                 }
 174            }
 175            @property focus {
 176                 [[Control the object item focused
 177
 178                   @since 1.10]]
 179                 get {
 180                 }
 181                 set {
 182                 }
 183                 values {
 184                      focused: bool; [[The focused state]]
 185                 }
 186            }
 187            @property style {
 188                 [[Control the style of an object item
 189
 190                   @since 1.9]]
 191                 get {
 192                 }
 193                 set {
 194                 }
 195                 values {
 196                      style: const (char) *; [[The style of object item]]
 197                 }
 198            }
 199            @property disabled {
 200                 [[Control the disabled state of an widget item.
 201
 202                   Elementary object item can be disabled, in which state they won't
 203                   receive input and, in general, will be themed differently from
 204                   their normal state, usually greyed out. Useful for contexts
 205                   where you don't want your users to interact with some of the
 206                   parts of you interface.
 207
 208                   This sets the state for the widget item, either disabling it or
 209                   enabling it back.]]
 210                 get {
 211                 }
 212                 set {
 213                 }
 214                 values {
 215                      disable: bool; [[$true, if the widget item is disabled, $false if it's enabled (or on errors)]]
 216                 }
 217            }
 218            access_order_get @const {
 219                 [[Get highlight order
 220
 221                   \@if MOBILE \@since_tizen 2.3
 222                   \@elseif WEARABLE \@since_tizen 2.3.1
 223                   \@endif
 224
 225                   @since 1.8
 226                 ]]
 227                 return: const(list<Evas.Object *>) *;
 228            }
 229            access_order_set {
 230                 [[Set highlight order
 231
 232                   \@if MOBILE \@since_tizen 2.3
 233                   \@elseif WEARABLE \@since_tizen 2.3.1
 234                   \@endif
 235
 236                   @since 1.8
 237                 ]]
 238                 params {
 239                      @in objs: own(list<Evas.Object *> *); [[Order of objects to pass highlight]]
 240                 }
 241            }
 242            widget_get @const {
 243                 [[Get the widget object's handle which contains a given item
 244
 245                   Note: This returns the widget object itself that an item belongs to.
 246                   Note: Every elm_object_item supports this API]]
 247                   return: Evas.Object*; [[The widget object]]
 248            }
 249            del {
 250                 [[Delete the given item.]]
 251            }
 252            pre_notify_del @protected {
 253                 [[Notify deletion of widget item before preparing deletion of item object.
 254
 255                   Note: This notification is not actaul item deletion.
 256                   See: elm_object_item_del_cb_set() for set callback on item deletion.]]
 257
 258                 legacy: null;
 259            }
 260            tooltip_text_set {
 261                 [[Set the text to be shown in a given object item's tooltips.
 262
 263                   Setup the text as tooltip to object. The item can have only one tooltip,
 264                   so any previous tooltip data - set with this function or
 265                   @.tooltip_content_cb_set - is removed.
 266
 267                   See: elm_object_tooltip_text_set() for more details.
 268
 269                   \@if MOBILE \@since_tizen 2.3
 270                   \@elseif WEARABLE \@since_tizen 2.3.1
 271                   \@endif
 272                 ]]
 273                 params {
 274                      text: const (char) *; [[The text to set in the content.]]
 275                 }
 276            }
 277            tooltip_translatable_text_set @protected {
 278                 [[Set widget item tooltip as a text string]]
 279                 legacy: null;
 280                 params {
 281                      text: const (char) *;
 282                 }
 283            }
 284            tooltip_unset {
 285                 [[Unset tooltip from item.
 286
 287                   Remove tooltip from item. The callback provided as del_cb to
 288                   @.tooltip_content_cb_set will be called to notify
 289                   it is not used anymore.
 290
 291                   See: elm_object_tooltip_unset() for more details.
 292                   See: @.tooltip_content_cb_set
 293
 294                   \@if MOBILE \@since_tizen 2.3
 295                   \@elseif WEARABLE \@since_tizen 2.3.1
 296                   \@endif
 297                 ]]
 298            }
 299            cursor_unset {
 300                 [[Unset any custom mouse pointer/cursor decoration set to be
 301                   shown, when the mouse pointer is over the given
 302                   item, thus making it show the default cursor again.
 303
 304                   Use this call to undo any custom settings on this item's cursor
 305                   decoration, bringing it back to defaults (no custom style set).
 306
 307                   See: elm_object_cursor_unset()
 308                   See: @.cursor.set
 309
 310                   \@if MOBILE \@since_tizen 2.3
 311                   \@elseif WEARABLE \@since_tizen 2.3.1
 312                   \@endif
 313                 ]]
 314            }
 315            part_content_unset {
 316                 [[Unset a content of an object item
 317
 318                   Note: Elementary object items may have many contents]]
 319                 params {
 320                      part: const (char) *; [[The content part name to unset (NULL for the default content)]]
 321                 }
 322                 return: Evas.Object*;
 323            }
 324            part_text_custom_update @protected {
 325                 [[Update additional text part content]]
 326                 legacy: null;
 327            }
 328            signal_callback_add {
 329                 [[Add a callback for a signal emitted by object item edje.
 330
 331                   This function connects a callback function to a signal emitted by the
 332                   edje object of the object item.
 333                   Globs can occur in either the emission or source name.
 334
 335                   @since 1.8]]
 336                 params {
 337                      emission: const (char) *; [[The signal's name.]]
 338                      source: const (char) *; [[The signal's source.]]
 339                      func: Elm_Object_Item_Signal_Cb; [[The callback function to be executed when the signal is emitted.]]
 340                      data: void *; [[A pointer to data to pass to the callback function.]]
 341                 }
 342            }
 343            signal_callback_del {
 344                 [[Remove a signal-triggered callback from a object item edje object.
 345
 346                   This function removes the last callback, previously attached to
 347                   a signal emitted by an underlying Edje object of $it, whose
 348                   parameters $emission, $source and $func match exactly with
 349                   those passed to a previous call to
 350                   @.signal_callback_add. The data pointer that was passed
 351                   to this call will be returned.
 352
 353                   See: @.signal_callback_add
 354
 355                   \@if MOBILE \@since_tizen 2.3
 356                   \@elseif WEARABLE \@since_tizen 2.3.1
 357                   \@endif
 358
 359                   @since 1.8
 360                 ]]
 361                 params {
 362                      emission: const (char) *; [[The signal's name.]]
 363                      source: const (char) *; [[The signal's source.]]
 364                      func: Elm_Object_Item_Signal_Cb; [[The callback function to be executed when the signal is emitted.]]
 365                 }
 366                 return: void*; [[The data pointer of the signal callback or $NULL, on errors.]]
 367            }
 368            signal_emit {
 369                 [[Send a signal to the edje object of the widget item.
 370
 371                   This function sends a signal to the edje object of the obj item. An
 372                   edje program can respond to a signal by specifying matching
 373                   'signal' and 'source' fields.]]
 374                 params {
 375                      emission: const (char) *; [[The signal's name.]]
 376                      source: const (char) *; [[The signal's source.]]
 377                 }
 378            }
 379            access_info_set {
 380                 [[Set the text to read out when in accessibility mode
 381
 382                   \@if MOBILE \@since_tizen 2.3
 383                   \@elseif WEARABLE \@since_tizen 2.3.1
 384                   \@endif
 385                 ]]
 386                 params {
 387                      txt: const (char) *; [[The text that describes the widget to people with poor or no vision]]
 388                 }
 389            }
 390            access_object_get @const {
 391                 [[Get an accessible object of the object item.
 392
 393                   \@if MOBILE \@since_tizen 2.3
 394                   \@elseif WEARABLE \@since_tizen 2.3.1
 395                   \@endif
 396
 397                   @since 1.8
 398                 ]]
 399                 return: Evas.Object*; [[Accessible object of the object item or NULL for any error]]
 400            }
 401            domain_translatable_part_text_set {
 402                 [[Set the text for an object item's part, marking it as translatable.
 403
 404                   The string to set as $text must be the original one. Do not pass the
 405                   return of $gettext() here. Elementary will translate the string
 406                   internally and set it on the object item using
 407                   @.part_text.set, also storing the original string so that it
 408                   can be automatically translated when the language is changed with
 409                   elm_language_set(). The $domain will be stored along to find the
 410                   translation in the correct catalog. It can be NULL, in which case it will use
 411                   whatever domain was set by the application with $textdomain(). This is
 412                   useful in case you are building a library on top of Elementary that will have
 413                   its own translatable strings, that should not be mixed with those of programs
 414                   using the library.
 415
 416                   \@if MOBILE \@since_tizen 2.3
 417                   \@elseif WEARABLE \@since_tizen 2.3.1
 418                   \@endif
 419
 420                   @since 1.8
 421                 ]]
 422                 params {
 423                      part: const (char) *; [[The name of the part to set]]
 424                      domain: const (char) *; [[The translation domain to use]]
 425                      label: const (char) *; [[The original, non-translated text to set]]
 426                 }
 427            }
 428            translatable_part_text_get @const {
 429                 [[Get the original string set as translatable for an object item.
 430
 431                   When setting translated strings, the function @.part_text.get
 432                   will return the translation returned by $gettext(). To get the original
 433                   string use this function.
 434
 435                   \@if MOBILE \@since_tizen 2.3
 436                   \@elseif WEARABLE \@since_tizen 2.3.1
 437                   \@endif
 438
 439                   @since 1.8
 440                 ]]
 441                 params {
 442                      part: const (char) *; [[The name of the part that was set]]
 443                 }
 444                 return: const (char)*; [[The original, untranslated string]]
 445            }
 446            translate @protected {
 447                 [[Query translate]]
 448                 legacy: null;
 449            }
 450            domain_part_text_translatable_set {
 451                 [[Mark the part text to be translatable or not.
 452
 453                   Once you mark the part text to be translatable, the text will be translated
 454                   internally regardless of @.part_text.set and
 455                   @.domain_translatable_part_text_set. In other case, if you
 456                   set the Elementary policy that all text will be translatable in default, you
 457                   can set the part text to not be translated by calling this API.
 458
 459                   See: @.domain_translatable_part_text_set
 460                   See: @.part_text.set
 461                   See: elm_policy()
 462
 463                   \@if MOBILE \@since_tizen 2.3
 464                   \@elseif WEARABLE \@since_tizen 2.3.1
 465                   \@endif
 466
 467                   @since 1.8
 468                 ]]
 469                 params {
 470                      part: const (char) *; [[The part name of the translatable text]]
 471                      domain: const (char) *; [[The translation domain to use]]
 472                      translatable: bool; [[$true, the part text will be translated internally. $false, otherwise.]]
 473                 }
 474            }
 475            track {
 476                 [[This returns track object of the item.
 477
 478                   Note: This gets a rectangle object that represents the object item's internal
 479                   object. If you want to check the geometry, visibility of the item, you
 480                   can call the evas apis such as evas_object_geometry_get(),
 481                   evas_object_visible_get() to the track object. Note that all of the
 482                   widget items may/may not have the internal object so this api may
 483                   return $NULL if the widget item doesn't have it. Additionally, the
 484                   widget item is managed/controlled by the widget, the widget item could
 485                   be changed(moved, resized even deleted) anytime by it's own widget's
 486                   decision. So please dont' change the track object as well as don't
 487                   keep the track object in your side as possible but get the track object
 488                   at the moment you need to refer. Otherwise, you need to add some
 489                   callbacks to the track object to track it's attributes changes.
 490
 491                   Warning: After use the track object, please call the
 492                   @.untrack() paired to elm_object_item_track
 493                   definitely to free the track object properly. Don't delete the
 494                   track object.
 495
 496                   See: @.untrack
 497                   See: @.track_get
 498
 499                   \@if MOBILE \@since_tizen 2.3
 500                   \@elseif WEARABLE \@since_tizen 2.3.1
 501                   \@endif
 502
 503                   @since 1.8
 504                 ]]
 505                 return: Evas.Object*; [[The track object]]
 506            }
 507            untrack {
 508                 [[This retrieve the track object of the item.
 509
 510                   Note: This retrieves the track object that was returned from
 511                   @.track.
 512
 513                   See: @.track
 514                   See: @.track_get
 515
 516                   \@if MOBILE \@since_tizen 2.3
 517                   \@elseif WEARABLE \@since_tizen 2.3.1
 518                   \@endif
 519
 520                   @since 1.8
 521                 ]]
 522            }
 523            track_get @const {
 524                 [[Get the track object reference count.
 525
 526                   Note: This gets the reference count for the track object. Whenever you call
 527                   the @.track, the reference count will be increased by
 528                   one. Likely the reference count will be decreased again when you call
 529                   the @.untrack. Unless the reference count reaches to
 530                   zero, the track object won't be deleted. So please be sure to call
 531                   @.untrack() paired to the elm_object_item_track call
 532                   count.
 533
 534                   See: @.track
 535                   See: @.track_get
 536
 537                   \@if MOBILE \@since_tizen 2.3
 538                   \@elseif WEARABLE \@since_tizen 2.3.1
 539                   \@endif
 540
 541                   @since 1.8
 542                 ]]
 543                 return: int;
 544            }
 545            track_cancel @protected {
 546                 [[Query track_cancel]]
 547                 legacy: null;
 548            }
 549            del_cb_set {
 550                 [[Set the function to be called when an item from the widget is
 551                   freed.
 552
 553                   Note: Every elm_object_item supports this API]]
 554                 params {
 555                      del_cb: Evas_Smart_Cb @nullable; [[The function called]]
 556                 }
 557            }
 558            tooltip_content_cb_set {
 559                 [[Set the content to be shown in the tooltip item.
 560
 561                   Setup the tooltip to item. The item can have only one tooltip,
 562                   so any previous tooltip data is removed. $func(with $data) will
 563                   be called every time that need show the tooltip and it should
 564                   return a valid Evas_Object. This object is then managed fully by
 565                   tooltip system and is deleted when the tooltip is gone.
 566
 567                   See: elm_object_tooltip_content_cb_set() for more details.
 568
 569                   \@if MOBILE \@since_tizen 2.3
 570                   \@elseif WEARABLE \@since_tizen 2.3.1
 571                   \@endif
 572                 ]]
 573                 params {
 574                      func: Elm_Tooltip_Item_Content_Cb @nullable; [[the function used to create the tooltip contents.]]
 575                      data: const (void) * @optional; [[what to provide to $func as callback data/context.]]
 576                      del_cb: Evas_Smart_Cb @optional; [[called when data is not needed anymore, either when another callback replaces $func, the tooltip is unset with @.tooltip_unset or the owner $item dies. This callback receives as the first parameter the given $data, and $event_info is the item.]]
 577
 578                 }
 579            }
 580            access_register {
 581                 [[Register object item as an accessible object.
 582
 583                   \@if MOBILE \@since_tizen 2.3
 584                   \@elseif WEARABLE \@since_tizen 2.3.1
 585                   \@endif
 586
 587                   @since 1.8
 588                 ]]
 589                 return: Evas.Object*; [[Accessible object of the object item or NULL for any error]]
 590            }
 591            access_unregister {
 592                 [[Unregister accessible object of the object item.
 593
 594                   \@if MOBILE \@since_tizen 2.3
 595                   \@elseif WEARABLE \@since_tizen 2.3.1
 596                   \@endif
 597
 598                   @since 1.8
 599                 ]]
 600            }
 601            access_order_unset {
 602                 [[Unset highlight order
 603
 604                   \@if MOBILE \@since_tizen 2.3
 605                   \@elseif WEARABLE \@since_tizen 2.3.1
 606                   \@endif
 607
 608                   @since 1.8
 609                 ]]
 610            }
 611            disable @protected {
 612                 legacy: null;
 613            }
 614            del_pre @protected {
 615                 legacy: null;
 616                 return: bool;
 617            }
 618            focus_next_object_get @const {
 619                 [[Get the next object with specific focus direction.
 620
 621                   \@if MOBILE \@since_tizen 2.3
 622                   \@elseif WEARABLE \@since_tizen 2.3.1
 623                   \@endif
 624
 625                   @since 1.16]]
 626                 params {
 627                      dir: Elm.Focus_Direction; [[Focus direction]]
 628                 }
 629                 return: Evas.Object *; [[Focus next object]]
 630            }
 631            focus_next_object_set {
 632                 [[Set the next object with specific focus direction.
 633
 634                   \@if MOBILE \@since_tizen 2.3
 635                   \@elseif WEARABLE \@since_tizen 2.3.1
 636                   \@endif
 637
 638                   @since 1.16]]
 639                 params {
 640                      next: Evas.Object * @nullable; [[Focus next object]]
 641                      dir: Elm.Focus_Direction; [[Focus direction]]
 642                 }
 643            }
 644            focus_next_item_get @const {
 645                 [[Get the next object item with specific focus direction.
 646
 647                   \@if MOBILE \@since_tizen 2.3
 648                   \@elseif WEARABLE \@since_tizen 2.3.1
 649                   \@endif
 650
 651                   @since 1.16]]
 652                 params {
 653                      dir: Elm.Focus_Direction; [[Focus direction]]
 654                 }
 655                 return: Elm_Object_Item *; [[Focus next object item]]
 656            }
 657            focus_next_item_set {
 658                 [[Set the next object item with specific focus direction.
 659
 660                   \@if MOBILE \@since_tizen 2.3
 661                   \@elseif WEARABLE \@since_tizen 2.3.1
 662                   \@endif
 663
 664                   @since 1.16]]
 665                 params {
 666                      next_item: Elm_Object_Item * @nullable; [[Focus next object item]]
 667                      dir: Elm.Focus_Direction; [[Focus direction]]
 668                 }
 669            }
 670            //TIZEN_ONLY(20161013): clean up elm color class feature
 671            @property class_color {
 672               set {
 673                  [[Set the color of color class for the Elementary widget item.
 674
 675                    Note: These color values are expected to be premultiplied by \@p a.
 676
 677                    \@if MOBILE \@since_tizen 3.0
 678                    \@elseif WEARABLE \@since_tizen 3.0
 679                    \@endif
 680                  ]]
 681                  return: bool;
 682                  legacy: elm_object_item_color_class_color_set;
 683               }
 684               get {
 685                  [[Get the color of color class for the Elementary widget item.
 686
 687                    Note: These color values are expected to be premultiplied by \@p a.
 688
 689                    \@if MOBILE \@since_tizen 3.0
 690                    \@elseif WEARABLE \@since_tizen 3.0
 691                    \@endif
 692                  ]]
 693                  return: bool;
 694                  legacy: elm_object_item_color_class_color_get;
 695               }
 696               keys {
 697                  color_class: const(char)*; [[The name of color class.]]
 698               }
 699               values {
 700                  r: int; [[The intensity of the red color.]]
 701                  g: int; [[The intensity of the green color.]]
 702                  b: int; [[The intensity of the blue color.]]
 703                  a: int; [[The alpha value.]]
 704               }
 705            }
 706            @property class_color2 {
 707               set {
 708                  [[Set the second color of color class for the Elementary widget item.
 709
 710                    The second color is commonly used for outline of text.
 711
 712                    Note: These color values are expected to be premultiplied by \@p a.
 713
 714                    \@if MOBILE \@since_tizen 3.0
 715                    \@elseif WEARABLE \@since_tizen 3.0
 716                    \@endif
 717                  ]]
 718                  return: bool;
 719                  legacy: elm_object_item_color_class_color2_set;
 720               }
 721               get {
 722                  [[Get the second color of color class for the Elementary widget item.
 723
 724                    The second color is commonly used for outline of text.
 725
 726                    Note: These color values are expected to be premultiplied by \@p a.
 727
 728                    \@if MOBILE \@since_tizen 3.0
 729                    \@elseif WEARABLE \@since_tizen 3.0
 730                    \@endif
 731                  ]]
 732                  return: bool;
 733                  legacy: elm_object_item_color_class_color2_get;
 734               }
 735               keys {
 736                  color_class: const(char)*; [[The name of color class.]]
 737               }
 738               values {
 739                  r: int; [[The intensity of the red color.]]
 740                  g: int; [[The intensity of the green color.]]
 741                  b: int; [[The intensity of the blue color.]]
 742                  a: int; [[The alpha value.]]
 743               }
 744            }
 745            @property class_color3 {
 746               set {
 747                  [[Set the third color of color class for the Elementary widget item.
 748
 749                    The third color is commonly used for shadow of text.
 750
 751                    Note: These color values are expected to be premultiplied by \@p a.
 752
 753                    \@if MOBILE \@since_tizen 3.0
 754                    \@elseif WEARABLE \@since_tizen 3.0
 755                    \@endif
 756                  ]]
 757                  return: bool;
 758                  legacy: elm_object_item_color_class_color3_set;
 759               }
 760               get {
 761                  [[Get the third color of color class for the Elementary widget item.
 762
 763                    The third color is commonly used for shadow of text.
 764
 765                    Note: These color values are expected to be premultiplied by \@p a.
 766
 767                    \@if MOBILE \@since_tizen 3.0
 768                    \@elseif WEARABLE \@since_tizen 3.0
 769                    \@endif
 770                  ]]
 771                  return: bool;
 772                  legacy: elm_object_item_color_class_color3_get;
 773               }
 774               keys {
 775                  color_class: const(char)*; [[The name of color class.]]
 776               }
 777               values {
 778                  r: int; [[The intensity of the red color.]]
 779                  g: int; [[The intensity of the green color.]]
 780                  b: int; [[The intensity of the blue color.]]
 781                  a: int; [[The alpha value.]]
 782               }
 783            }
 784            class_color_del {
 785               [[Delete the color class for the Elementary widget item.
 786
 787                 Deleting the color class will revert it to the values defined by
 788                 elm_color_class_set() or the theme file.
 789
 790                 \@if MOBILE \@since_tizen 3.0
 791                 \@elseif WEARABLE \@since_tizen 3.0
 792                 \@endif
 793               ]]
 794               legacy: elm_object_item_color_class_del;
 795               params {
 796                  @in color_class: const(char)*;
 797               }
 798            }
 799            class_color_clear {
 800               [[Delete all color classes for the Elementary widget item.
 801
 802                 This function deletes any color classes defined for the Elementary widget item.
 803                 Clearing color classes will revert the color of all parts to the values
 804                 defined by elm_color_class_set() or the theme file.
 805
 806                 \@if MOBILE \@since_tizen 3.0
 807                 \@elseif WEARABLE \@since_tizen 3.0
 808                 \@endif
 809               ]]
 810               legacy: elm_object_item_color_class_clear;
 811            }
 812            //
 813       }
 814       implements {
 815            Eo.Base.constructor;
 816            Eo.Base.destructor;
 817            //TIZEN_ONLY(20150713) : add widget_item name setter
 818            Elm_Interface_Atspi_Accessible.name.get;
 819            Elm_Interface_Atspi_Accessible.name.set;
 820            //
 821            //TIZEN_ONLY(20161111) add widget/widget_item description get/set
 822            Elm_Interface_Atspi_Accessible.description.set;
 823            Elm_Interface_Atspi_Accessible.description.get;
 824            //
 825            Elm_Interface_Atspi_Accessible.state_set.get;
 826            Elm_Interface_Atspi_Accessible.parent.get;
 827            //TIZEN_ONLY(20150709) : atspi relations api
 828            Elm_Interface_Atspi_Accessible.relationship_append;
 829            Elm_Interface_Atspi_Accessible.relationship_remove;
 830            Elm_Interface_Atspi_Accessible.relation_set.get;
 831            Elm_Interface_Atspi_Accessible.relationships_clear;
 832            //
 833            //TIZEN_ONLY(20150731) : add i18n support for name and description
 834            Elm_Interface_Atspi_Accessible.translation_domain.set;
 835            Elm_Interface_Atspi_Accessible.translation_domain.get;
 836            //
 837            //TIZEN_ONLY(20160726): add API elm_atspi_accessible_can_highlight_set/get
 838            Elm_Interface_Atspi_Accessible.can_highlight.set;
 839            Elm_Interface_Atspi_Accessible.can_highlight.get;
 840            //
 841            Elm_Interface_Atspi_Component.extents.get;
 842            Elm_Interface_Atspi_Component.extents.set;
 843            Elm_Interface_Atspi_Component.alpha.get;
 844            Elm_Interface_Atspi_Component.layer.get;
 845            Elm_Interface_Atspi_Component.focus_grab;
 846            Elm_Interface_Atspi_Component.highlight_grab;
 847            Elm_Interface_Atspi_Component.highlight_clear;
 848            //TIZEN_ONLY(20160527): widget item: add AtspiAction interface to all widget items
 849            Elm_Interface_Atspi_Widget_Action.elm_actions.get;
 850            //
 851       }
 852 }