src/lib/elm_radio.c

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