src/lib/elm_radio.c

   1 #include <Elementary.h>
   2 #include "elm_priv.h"
   3
   4 /**
   5  * @defgroup Radio Radio
   6  * @ingroup Elementary
   7  *
   8  * The radio button allows for 1 or more selectors to be created to select 1
   9  * of a set of options.
  10  *
  11  * Signals that you can add callbacks for are:
  12  *
  13  * changed - This is called whenever the user changes the state of one of the
  14  * radio objects within the group of radio objects that work together.
  15  *
  16  * A radio object contains an indicator, an optional Label and an optional
  17  * icon object. They work normally in groups of 2 or more. When you create a
  18  * radio (if it is not the first member of the group), simply add it to the
  19  * group by adding it to any other member of the group that already exists
  20  * (or the first member) with elm_radio_group_add() with the second parameter
  21  * being the existing group member. The radio object(s) will select from one
  22  * of a set of integer values, so any value they are configuring needs to be
  23  * mapped to a set of integers. To configure what value that radio object
  24  * represents, use  elm_radio_state_value_set() to set the integer it
  25  * represents. To set the value the whole group is to indicate use
  26  * elm_radio_value_set() on any group member, and to get the groups value use
  27  * elm_radio_value_get(). For convenience the radio objects are also able to
  28  * directly set an integer (int) to the value that is selected. To specify
  29  * the pointer to this integer to modify, use elm_radio_value_pointer_set().
  30  * The radio objects will modify this directly. That implies the pointer must
  31  * point to valid memory for as long as the radio objects exist.
  32  */
  33
  34 typedef struct _Widget_Data Widget_Data;
  35 typedef struct _Group Group;
  36
  37 struct _Group
  38 {
  39    int value;
  40    int *valuep;
  41    Eina_List *radios;
  42 };
  43
  44 struct _Widget_Data
  45 {
  46    Evas_Object *radio;
  47    Evas_Object *icon;
  48    int value;
  49    const char *label;
  50    Eina_Bool state;
  51    Group *group;
  52 };
  53
  54 static const char *widtype = NULL;
  55 static void _state_set(Evas_Object *obj, Eina_Bool state);
  56 static void _del_hook(Evas_Object *obj);
  57 static void _theme_hook(Evas_Object *obj);
  58 static void _disable_hook(Evas_Object *obj);
  59 static void _sizing_eval(Evas_Object *obj);
  60 static void _changed_size_hints(void *data, Evas *e, Evas_Object *obj, void *event_info);
  61 static void _sub_del(void *data, Evas_Object *obj, void *event_info);
  62 static void _signal_radio_on(void *data, Evas_Object *obj, const char *emission, const char *source);
  63
  64 static const char SIG_CHANGED[] = "changed";
  65 static const Evas_Smart_Cb_Description _signals[] = {
  66   {SIG_CHANGED, ""},
  67   {NULL, NULL}
  68 };
  69
  70 static void
  71 _del_hook(Evas_Object *obj)
  72 {
  73    Widget_Data *wd = elm_widget_data_get(obj);
  74    if (!wd) return;
  75    if (wd->label) eina_stringshare_del(wd->label);
  76    wd->group->radios = eina_list_remove(wd->group->radios, obj);
  77    if (!wd->group->radios) free(wd->group);
  78    wd->group = NULL;
  79    free(wd);
  80 }
  81
  82 static void
  83 _theme_hook(Evas_Object *obj)
  84 {
  85    Widget_Data *wd = elm_widget_data_get(obj);
  86    if (!wd) return;
  87    _elm_theme_object_set(obj, wd->radio, "radio", "base", elm_widget_style_get(obj));
  88    if (wd->icon)
  89      edje_object_signal_emit(wd->radio, "elm,state,icon,visible", "elm");
  90    else
  91      edje_object_signal_emit(wd->radio, "elm,state,icon,hidden", "elm");
  92    if (wd->state)
  93      edje_object_signal_emit(wd->radio, "elm,state,radio,on", "elm");
  94    else
  95      edje_object_signal_emit(wd->radio, "elm,state,radio,off", "elm");
  96    if (wd->label)
  97      edje_object_signal_emit(wd->radio, "elm,state,text,visible", "elm");
  98    else
  99      edje_object_signal_emit(wd->radio, "elm,state,text,hidden", "elm");
 100    edje_object_part_text_set(wd->radio, "elm.text", wd->label);
 101    edje_object_message_signal_process(wd->radio);
 102    edje_object_scale_set(wd->radio, elm_widget_scale_get(obj) * _elm_config->scale);
 103    _sizing_eval(obj);
 104 }
 105
 106 static void
 107 _disable_hook(Evas_Object *obj)
 108 {
 109    Widget_Data *wd = elm_widget_data_get(obj);
 110    if (!wd) return;
 111    if (elm_widget_disabled_get(obj))
 112      {
 113         edje_object_signal_emit(wd->radio, "elm,state,disabled", "elm");
 114         if (wd->state) _state_set(obj, 0);
 115      }
 116    else
 117      edje_object_signal_emit(wd->radio, "elm,state,enabled", "elm");
 118 }
 119
 120 static void
 121 _sizing_eval(Evas_Object *obj)
 122 {
 123    Widget_Data *wd = elm_widget_data_get(obj);
 124    Evas_Coord minw = -1, minh = -1;
 125    if (!wd) return;
 126    elm_coords_finger_size_adjust(1, &minw, 1, &minh);
 127    edje_object_size_min_restricted_calc(wd->radio, &minw, &minh, minw, minh);
 128    elm_coords_finger_size_adjust(1, &minw, 1, &minh);
 129    evas_object_size_hint_min_set(obj, minw, minh);
 130    evas_object_size_hint_max_set(obj, -1, -1);
 131 }
 132
 133 static void
 134 _changed_size_hints(void *data, Evas *e __UNUSED__, Evas_Object *obj, void *event_info __UNUSED__)
 135 {
 136    Widget_Data *wd = elm_widget_data_get(data);
 137    if (!wd) return;
 138    if (obj != wd->icon) return;
 139    _sizing_eval(data);
 140 }
 141
 142 static void
 143 _sub_del(void *data __UNUSED__, Evas_Object *obj, void *event_info)
 144 {
 145    Widget_Data *wd = elm_widget_data_get(obj);
 146    Evas_Object *sub = event_info;
 147    if (!wd) return;
 148    if (sub == wd->icon)
 149      {
 150         edje_object_signal_emit(wd->radio, "elm,state,icon,hidden", "elm");
 151         evas_object_event_callback_del_full
 152           (sub, EVAS_CALLBACK_CHANGED_SIZE_HINTS, _changed_size_hints, obj);
 153         wd->icon = NULL;
 154         _sizing_eval(obj);
 155      }
 156 }
 157
 158 static void
 159 _state_set(Evas_Object *obj, Eina_Bool state)
 160 {
 161    Widget_Data *wd = elm_widget_data_get(obj);
 162    if (!wd) return;
 163    if ((state != wd->state) && (!elm_widget_disabled_get(obj)))
 164      {
 165         wd->state = state;
 166         if (wd->state)
 167           edje_object_signal_emit(wd->radio, "elm,state,radio,on", "elm");
 168         else
 169           edje_object_signal_emit(wd->radio, "elm,state,radio,off", "elm");
 170      }
 171 }
 172
 173 static void
 174 _state_set_all(Widget_Data *wd)
 175 {
 176    const Eina_List *l;
 177    Evas_Object *child, *selected = NULL;
 178    Eina_Bool disabled = EINA_FALSE;
 179    EINA_LIST_FOREACH(wd->group->radios, l, child)
 180      {
 181         Widget_Data *wd2 = elm_widget_data_get(child);
 182         if (wd2->state) selected = child;
 183         if (wd2->value == wd->group->value)
 184           {
 185              _state_set(child, 1);
 186              if (!wd2->state) disabled = EINA_TRUE;
 187           }
 188         else _state_set(child, 0);
 189      }
 190    if (disabled && selected) _state_set(selected, 1);
 191 }
 192
 193 static void
 194 _signal_radio_on(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
 195 {
 196    Widget_Data *wd = elm_widget_data_get(data);
 197    if (!wd) return;
 198    if (wd->group->value == wd->value) return;
 199    wd->group->value = wd->value;
 200    if (wd->group->valuep) *(wd->group->valuep) = wd->group->value;
 201    _state_set_all(wd);
 202    evas_object_smart_callback_call(data, SIG_CHANGED, NULL);
 203 }
 204
 205 /**
 206   * Add a new radio to the parent
 207   *
 208   * @param[in] parent The parent object
 209   * @return The new object or NULL if it cannot be created
 210   *
 211   * @ingroup Radio
 212   */
 213 EAPI Evas_Object *
 214 elm_radio_add(Evas_Object *parent)
 215 {
 216    Evas_Object *obj;
 217    Evas *e;
 218    Widget_Data *wd;
 219
 220    wd = ELM_NEW(Widget_Data);
 221    e = evas_object_evas_get(parent);
 222    obj = elm_widget_add(e);
 223    ELM_SET_WIDTYPE(widtype, "radio");
 224    elm_widget_type_set(obj, "radio");
 225    elm_widget_sub_object_add(parent, obj);
 226    elm_widget_data_set(obj, wd);
 227    elm_widget_del_hook_set(obj, _del_hook);
 228    elm_widget_theme_hook_set(obj, _theme_hook);
 229    elm_widget_disable_hook_set(obj, _disable_hook);
 230
 231    wd->radio = edje_object_add(e);
 232    _elm_theme_object_set(obj, wd->radio, "radio", "base", "default");
 233    edje_object_signal_callback_add(wd->radio, "elm,action,radio,on", "", _signal_radio_on, obj);
 234    edje_object_signal_callback_add(wd->radio, "elm,action,radio,toggle", "", _signal_radio_on, obj);
 235    elm_widget_resize_object_set(obj, wd->radio);
 236
 237    evas_object_smart_callback_add(obj, "sub-object-del", _sub_del, obj);
 238
 239    wd->group = calloc(1, sizeof(Group));
 240    wd->group->radios = eina_list_append(wd->group->radios, obj);
 241    wd->state = 0;
 242
 243    _sizing_eval(obj);
 244
 245    // TODO: convert Elementary to subclassing of Evas_Smart_Class
 246    // TODO: and save some bytes, making descriptions per-class and not instance!
 247    evas_object_smart_callbacks_descriptions_set(obj, _signals);
 248    return obj;
 249 }
 250
 251 /**
 252  * Set the text label of the radio object
 253  *
 254  * @param[in] obj The radio object
 255  * @param[in] label The text label string in UTF-8
 256  *
 257  * @ingroup Radio
 258  */
 259 EAPI void
 260 elm_radio_label_set(Evas_Object *obj, const char *label)
 261 {
 262    ELM_CHECK_WIDTYPE(obj, widtype);
 263    Widget_Data *wd = elm_widget_data_get(obj);
 264    if (!wd) return;
 265    eina_stringshare_replace(&wd->label, label);
 266    if (label)
 267      {
 268         edje_object_signal_emit(wd->radio, "elm,state,text,visible", "elm");
 269         edje_object_message_signal_process(wd->radio);
 270      }
 271    else
 272      {
 273         edje_object_signal_emit(wd->radio, "elm,state,text,hidden", "elm");
 274         edje_object_message_signal_process(wd->radio);
 275      }
 276    edje_object_part_text_set(wd->radio, "elm.text", label);
 277    _sizing_eval(obj);
 278 }
 279
 280 /**
 281  * Get the text label of the radio object
 282  *
 283  * @param[in] obj The radio object
 284  * @return The text label string in UTF-8
 285  *
 286  * @ingroup Radio
 287  */
 288 EAPI const char *
 289 elm_radio_label_get(const Evas_Object *obj)
 290 {
 291    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
 292    Widget_Data *wd = elm_widget_data_get(obj);
 293    if (!wd) return NULL;
 294    return wd->label;
 295 }
 296
 297 /**
 298  * Set the icon object of the radio object
 299  *
 300  * Once the icon object is set, a previously set one will be deleted.
 301  *
 302  * @param[in] obj The radio object
 303  * @param[in] icon The icon object
 304  *
 305  * @ingroup Radio
 306  */
 307 EAPI void
 308 elm_radio_icon_set(Evas_Object *obj, Evas_Object *icon)
 309 {
 310    ELM_CHECK_WIDTYPE(obj, widtype);
 311    Widget_Data *wd = elm_widget_data_get(obj);
 312    if (!wd) return;
 313    if (wd->icon == icon) return;
 314    if (wd->icon) evas_object_del(wd->icon);
 315    wd->icon = icon;
 316    if (icon)
 317      {
 318         elm_widget_sub_object_add(obj, icon);
 319         evas_object_event_callback_add(icon, EVAS_CALLBACK_CHANGED_SIZE_HINTS,
 320                                        _changed_size_hints, obj);
 321         edje_object_part_swallow(wd->radio, "elm.swallow.content", icon);
 322         edje_object_signal_emit(wd->radio, "elm,state,icon,visible", "elm");
 323         edje_object_message_signal_process(wd->radio);
 324      }
 325    _sizing_eval(obj);
 326 }
 327
 328 /**
 329  * Get the icon object of the radio object
 330  *
 331  * @param[in] obj The radio object
 332  * @return The icon object
 333  *
 334  * @ingroup Radio
 335  */
 336 EAPI Evas_Object *
 337 elm_radio_icon_get(const Evas_Object *obj)
 338 {
 339    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
 340    Widget_Data *wd = elm_widget_data_get(obj);
 341    if (!wd) return NULL;
 342    return wd->icon;
 343 }
 344
 345 /**
 346  * Add this radio to a group of other radio objects
 347  *
 348  * Radio objects work in groups. Each member should have a different integer
 349  * value assigned. In order ro have them work as a group, they need to know
 350  * about eacthother. This adds the given radio object to the group of which
 351  * the group object indicated is a member.
 352  *
 353  * @param[in] obj The radio object
 354  * @param[in] group The object whose group the object is to join
 355  *
 356  * @ingroup Radio
 357  */
 358 EAPI void
 359 elm_radio_group_add(Evas_Object *obj, Evas_Object *group)
 360 {
 361    ELM_CHECK_WIDTYPE(obj, widtype);
 362    Widget_Data *wd = elm_widget_data_get(obj);
 363    Widget_Data *wd2 = elm_widget_data_get(group);
 364    if (!wd) return;
 365    if (!wd2)
 366      {
 367         if (eina_list_count(wd->group->radios) == 1)
 368           return;
 369         wd->group->radios = eina_list_remove(wd->group->radios, obj);
 370         wd->group = calloc(1, sizeof(Group));
 371         wd->group->radios = eina_list_append(wd->group->radios, obj);
 372      }
 373    else if (wd->group == wd2->group) return;
 374    else
 375      {
 376         wd->group->radios = eina_list_remove(wd->group->radios, obj);
 377         if (!wd->group->radios) free(wd->group);
 378         wd->group = wd2->group;
 379         wd->group->radios = eina_list_append(wd->group->radios, obj);
 380      }
 381    if (wd->value == wd->group->value) _state_set(obj, 1);
 382    else _state_set(obj, 0);
 383 }
 384
 385 /**
 386  * Set the integer value that this radio object represents
 387  *
 388  * This sets the value of the radio.
 389  *
 390  * @param[in] obj The radio object
 391  * @param[in] value The value to use if this radio object is selected
 392  *
 393  * @ingroup Radio
 394  */
 395 EAPI void
 396 elm_radio_state_value_set(Evas_Object *obj, int value)
 397 {
 398    ELM_CHECK_WIDTYPE(obj, widtype);
 399    Widget_Data *wd = elm_widget_data_get(obj);
 400    if (!wd) return;
 401    wd->value = value;
 402    if (wd->value == wd->group->value) _state_set(obj, 1);
 403    else _state_set(obj, 0);
 404 }
 405
 406 /**
 407  * Set the value of the radio.
 408  *
 409  * This sets the value of the radio group and will also set the value if
 410  * pointed to, to the value supplied, but will not call any callbacks.
 411  *
 412  * @param[in] obj The radio object
 413  * @param[in] value The value to use for the group
 414  *
 415  * @ingroup Radio
 416  */
 417 EAPI void
 418 elm_radio_value_set(Evas_Object *obj, int value)
 419 {
 420    ELM_CHECK_WIDTYPE(obj, widtype);
 421    Widget_Data *wd = elm_widget_data_get(obj);
 422    if (!wd) return;
 423    if (value == wd->group->value) return;
 424    wd->group->value = value;
 425    if (wd->group->valuep) *(wd->group->valuep) = wd->group->value;
 426    _state_set_all(wd);
 427 }
 428
 429 /**
 430  * Get the state of the radio object
 431  *
 432  * @param[in] obj The radio object
 433  * @return The integer state
 434  *
 435  * @ingroup Radio
 436  */
 437 EAPI int
 438 elm_radio_value_get(const Evas_Object *obj)
 439 {
 440    ELM_CHECK_WIDTYPE(obj, widtype) 0;
 441    Widget_Data *wd = elm_widget_data_get(obj);
 442    if (!wd) return 0;
 443    return wd->group->value;
 444 }
 445
 446 /**
 447  * Set a convenience pointer to a integer to change
 448  *
 449  * This sets a pointer to a integer, that, in addition to the radio objects
 450  * state will also be modified directly. To stop setting the object pointed
 451  * to simply use NULL as the valuep parameter. If valuep is not NULL, then
 452  * when this is called, the radio objects state will also be modified to
 453  * reflect the value of the integer valuep points to, just like calling
 454  * elm_radio_value_set().
 455  *
 456  * @param[in] obj The radio object
 457  * @param[in] valuep Pointer to the integer to modify
 458  *
 459  * @ingroup Radio
 460  */
 461 EAPI void
 462 elm_radio_value_pointer_set(Evas_Object *obj, int *valuep)
 463 {
 464    ELM_CHECK_WIDTYPE(obj, widtype);
 465    Widget_Data *wd = elm_widget_data_get(obj);
 466    if (!wd) return;
 467    if (valuep)
 468      {
 469         wd->group->valuep = valuep;
 470         if (*(wd->group->valuep) != wd->group->value)
 471           {
 472              wd->group->value = *(wd->group->valuep);
 473              _state_set_all(wd);
 474           }
 475      }
 476    else
 477      {
 478         wd->group->valuep = NULL;
 479      }
 480 }