1

2
/**
3
 * @file lv_slider.c
4
 *
5
 */
6

7
/*********************
8
 *      INCLUDES
9
 *********************/
10
#include "lv_slider.h"
11
#if USE_LV_SLIDER != 0
12

13
#include "../lv_core/lv_group.h"
14
#include "../lv_draw/lv_draw.h"
15
#include "../lv_themes/lv_theme.h"
16
#include "../lv_misc/lv_math.h"
17

18
/*********************
19
 *      DEFINES
20
 *********************/
21
#define LV_SLIDER_SIZE_MIN      4           /*hor. pad and ver. pad cannot make the bar or indicator smaller then this [px]*/
22
#define LV_SLIDER_NOT_PRESSED   INT16_MIN
23

24
/**********************
25
 *      TYPEDEFS
26
 **********************/
27

28
/**********************
29
 *  STATIC PROTOTYPES
30
 **********************/
31
static bool lv_slider_design(lv_obj_t * slider, const lv_area_t * mask, lv_design_mode_t mode);
32
static lv_res_t lv_slider_signal(lv_obj_t * slider, lv_signal_t sign, void * param);
33

34
/**********************
35
 *  STATIC VARIABLES
36
 **********************/
37
static lv_design_func_t ancestor_design_f;
38
static lv_signal_func_t ancestor_signal;
39

40
/**********************
41
 *      MACROS
42
 **********************/
43

44
/**********************
45
 *   GLOBAL FUNCTIONS
46
 **********************/
47

48
/**
49
 * Create a slider objects
50
 * @param par pointer to an object, it will be the parent of the new slider
51
 * @param copy pointer to a slider object, if not NULL then the new object will be copied from it
52
 * @return pointer to the created slider
53
 */
54
lv_obj_t * lv_slider_create(lv_obj_t * par, const lv_obj_t * copy)
55
{
56
    LV_LOG_TRACE("slider create started");
57

58
    /*Create the ancestor slider*/
59
    lv_obj_t * new_slider = lv_bar_create(par, copy);
60
    lv_mem_assert(new_slider);
61
    if(new_slider == NULL) return NULL;
62

63
    if(ancestor_design_f == NULL) ancestor_design_f = lv_obj_get_design_func(new_slider);
64
    if(ancestor_signal == NULL) ancestor_signal = lv_obj_get_signal_func(new_slider);
65

66
    /*Allocate the slider type specific extended data*/
67
    lv_slider_ext_t * ext = lv_obj_allocate_ext_attr(new_slider, sizeof(lv_slider_ext_t));
68
    lv_mem_assert(ext);
69
    if(ext == NULL) return NULL;
70

71
    /*Initialize the allocated 'ext' */
72
    ext->action = NULL;
73
    ext->drag_value = LV_SLIDER_NOT_PRESSED;
74
    ext->style_knob = &lv_style_pretty;
75
    ext->knob_in = 0;
76

77
    /*The signal and design functions are not copied so set them here*/
78
    lv_obj_set_signal_func(new_slider, lv_slider_signal);
79
    lv_obj_set_design_func(new_slider, lv_slider_design);
80

81
    /*Init the new slider slider*/
82
    if(copy == NULL) {
83
        lv_obj_set_click(new_slider, true);
84
        lv_obj_set_protect(new_slider, LV_PROTECT_PRESS_LOST);
85

86
        /*Set the default styles*/
87
        lv_theme_t * th = lv_theme_get_current();
88
        if(th) {
89
            lv_slider_set_style(new_slider, LV_SLIDER_STYLE_BG, th->slider.bg);
90
            lv_slider_set_style(new_slider, LV_SLIDER_STYLE_INDIC, th->slider.indic);
91
            lv_slider_set_style(new_slider, LV_SLIDER_STYLE_KNOB, th->slider.knob);
92
        } else {
93
            lv_slider_set_style(new_slider, LV_SLIDER_STYLE_KNOB, ext->style_knob);
94
        }
95
    }
96
    /*Copy an existing slider*/
97
    else {
98
        lv_slider_ext_t * copy_ext = lv_obj_get_ext_attr(copy);
99
        ext->style_knob = copy_ext->style_knob;
100
        ext->action = copy_ext->action;
101
        ext->knob_in = copy_ext->knob_in;
102
        /*Refresh the style with new signal function*/
103
        lv_obj_refresh_style(new_slider);
104
    }
105

106

107
    LV_LOG_INFO("slider created");
108

109

110
    return new_slider;
111
}
112

113
/*=====================
114
 * Setter functions
115
 *====================*/
116

117
/**
118
 * Set a function which will be called when a new value is set on the slider
119
 * @param slider pointer to slider object
120
 * @param action a callback function
121
 */
122
void lv_slider_set_action(lv_obj_t * slider, lv_action_t action)
123
{
124
    lv_slider_ext_t * ext = lv_obj_get_ext_attr(slider);
125
    ext->action = action;
126
}
127

128
/**
129
 * Set the 'knob in' attribute of a slider
130
 * @param slider pointer to slider object
131
 * @param in true: the knob is drawn always in the slider;
132
 *           false: the knob can be out on the edges
133
 */
134
void lv_slider_set_knob_in(lv_obj_t * slider, bool in)
135
{
136
    lv_slider_ext_t * ext = lv_obj_get_ext_attr(slider);
137
    if(ext->knob_in == in) return;
138

139
    ext->knob_in = in == false ? 0 : 1;
140
    lv_obj_invalidate(slider);
141
}
142

143
/**
144
 * Set a style of a slider
145
 * @param slider pointer to a slider object
146
 * @param type which style should be set
147
 * @param style pointer to a style
148
 */
149
void lv_slider_set_style(lv_obj_t * slider, lv_slider_style_t type, lv_style_t * style)
150
{
151
    lv_slider_ext_t * ext = lv_obj_get_ext_attr(slider);
152

153
    switch(type) {
154
        case LV_SLIDER_STYLE_BG:
155
            lv_bar_set_style(slider, LV_BAR_STYLE_BG, style);
156
            break;
157
        case LV_SLIDER_STYLE_INDIC:
158
            lv_bar_set_style(slider, LV_BAR_STYLE_INDIC, style);
159
            break;
160
        case LV_SLIDER_STYLE_KNOB:
161
            ext->style_knob = style;
162
            lv_obj_refresh_ext_size(slider);
163
            break;
164
    }
165
}
166

167
/*=====================
168
 * Getter functions
169
 *====================*/
170

171
/**
172
 * Get the value of a slider
173
 * @param slider pointer to a slider object
174
 * @return the value of the slider
175
 */
176
int16_t lv_slider_get_value(const lv_obj_t * slider)
177
{
178
    lv_slider_ext_t * ext = lv_obj_get_ext_attr(slider);
179

180
    if(ext->drag_value != LV_SLIDER_NOT_PRESSED) return ext->drag_value;
181
    else return lv_bar_get_value(slider);
182
}
183

184
/**
185
 * Get the slider action function
186
 * @param slider pointer to slider object
187
 * @return the callback function
188
 */
189
lv_action_t lv_slider_get_action(const lv_obj_t * slider)
190
{
191
    lv_slider_ext_t * ext = lv_obj_get_ext_attr(slider);
192
    return ext->action;
193
}
194

195
/**
196
 * Give the slider is being dragged or not
197
 * @param slider pointer to a slider object
198
 * @return true: drag in progress false: not dragged
199
 */
200
bool lv_slider_is_dragged(const lv_obj_t * slider)
201
{
202
    lv_slider_ext_t * ext = lv_obj_get_ext_attr(slider);
203
    return ext->drag_value == LV_SLIDER_NOT_PRESSED ? false : true;
204
}
205

206
/**
207
 * Get the 'knob in' attribute of a slider
208
 * @param slider pointer to slider object
209
 * @return true: the knob is drawn always in the slider;
210
 *         false: the knob can be out on the edges
211
 */
212
bool lv_slider_get_knob_in(const lv_obj_t * slider)
213
{
214
    lv_slider_ext_t * ext = lv_obj_get_ext_attr(slider);
215
    return ext->knob_in == 0 ? false : true;
216
}
217

218
/**
219
 * Get a style of a slider
220
 * @param slider pointer to a slider object
221
 * @param type which style should be get
222
 * @return style pointer to a style
223
 */
224
lv_style_t * lv_slider_get_style(const lv_obj_t * slider, lv_slider_style_t type)
225
{
226
    lv_style_t * style = NULL;
227
    lv_slider_ext_t * ext = lv_obj_get_ext_attr(slider);
228

229
    switch(type) {
230
        case LV_SLIDER_STYLE_BG:
231
            style = lv_bar_get_style(slider, LV_BAR_STYLE_BG);
232
            break;
233
        case LV_SLIDER_STYLE_INDIC:
234
            style = lv_bar_get_style(slider, LV_BAR_STYLE_INDIC);
235
            break;
236
        case LV_SLIDER_STYLE_KNOB:
237
            style = ext->style_knob;
238
            break;
239
        default:
240
            style = NULL;
241
            break;
242
    }
243

244
    return style;
245
}
246

247
/**********************
248
 *   STATIC FUNCTIONS
249
 **********************/
250

251

252
/**
253
 * Handle the drawing related tasks of the sliders
254
 * @param slider pointer to an object
255
 * @param mask the object will be drawn only in this area
256
 * @param mode LV_DESIGN_COVER_CHK: only check if the object fully covers the 'mask_p' area
257
 *                                  (return 'true' if yes)
258
 *             LV_DESIGN_DRAW: draw the object (always return 'true')
259
 *             LV_DESIGN_DRAW_POST: drawing after every children are drawn
260
 * @param return true/false, depends on 'mode'
261
 */
262
static bool lv_slider_design(lv_obj_t * slider, const lv_area_t * mask, lv_design_mode_t mode)
263
{
264
    /*Return false if the object is not covers the mask_p area*/
265
    if(mode == LV_DESIGN_COVER_CHK) {
266
        return false;
267
    }
268
    /*Draw the object*/
269
    else if(mode == LV_DESIGN_DRAW_MAIN) {
270
        lv_slider_ext_t * ext = lv_obj_get_ext_attr(slider);
271

272
        lv_style_t * style_bg = lv_slider_get_style(slider, LV_SLIDER_STYLE_BG);
273
        lv_style_t * style_knob = lv_slider_get_style(slider, LV_SLIDER_STYLE_KNOB);
274
        lv_style_t * style_indic = lv_slider_get_style(slider, LV_SLIDER_STYLE_INDIC);
275

276
        lv_opa_t opa_scale = lv_obj_get_opa_scale(slider);
277

278
        lv_coord_t slider_w = lv_area_get_width(&slider->coords);
279
        lv_coord_t slider_h = lv_area_get_height(&slider->coords);
280

281
        /*Draw the bar*/
282
        lv_area_t area_bg;
283
        lv_area_copy(&area_bg, &slider->coords);
284

285
        /*Be sure at least LV_SLIDER_SIZE_MIN  size will remain*/
286
        lv_coord_t pad_ver_bg = style_bg->body.padding.ver;
287
        lv_coord_t pad_hor_bg = style_bg->body.padding.hor;
288
        if(pad_ver_bg * 2 + LV_SLIDER_SIZE_MIN > lv_area_get_height(&area_bg)) {
289
            pad_ver_bg = (lv_area_get_height(&area_bg) - LV_SLIDER_SIZE_MIN) >> 1;
290
        }
291
        if(pad_hor_bg * 2 + LV_SLIDER_SIZE_MIN > lv_area_get_width(&area_bg)) {
292
            pad_hor_bg = (lv_area_get_width(&area_bg) - LV_SLIDER_SIZE_MIN) >> 1;
293
        }
294

295
        if(ext->knob_in) {  /*Enable extra size if the knob is inside */
296
            area_bg.x1 += pad_hor_bg;
297
            area_bg.x2 -= pad_hor_bg;
298
            area_bg.y1 += pad_hor_bg;
299
            area_bg.y2 -= pad_hor_bg;
300
        } else  { /*Let space only in the perpendicular directions*/
301
            area_bg.x1 += slider_w < slider_h ? pad_hor_bg : 0;   /*Pad only for vertical slider*/
302
            area_bg.x2 -= slider_w < slider_h ? pad_hor_bg : 0;   /*Pad only for vertical slider*/
303
            area_bg.y1 += slider_w > slider_h ? pad_ver_bg : 0;   /*Pad only for horizontal slider*/
304
            area_bg.y2 -= slider_w > slider_h ? pad_ver_bg : 0;   /*Pad only for horizontal slider*/
305
        }
306

307

308
#if USE_LV_GROUP == 0
309
        lv_draw_rect(&area_bg, mask, style_bg, lv_obj_get_opa_scale(slider));
310
#else
311
        /* Draw the borders later if the bar is focused.
312
         * At value = 100% the indicator can cover to whole background and the focused style won't be visible*/
313
        if(lv_obj_is_focused(slider)) {
314
            lv_style_t style_tmp;
315
            lv_style_copy(&style_tmp, style_bg);
316
            style_tmp.body.border.width = 0;
317
            lv_draw_rect(&area_bg, mask, &style_tmp, opa_scale);
318
        } else {
319
            lv_draw_rect(&area_bg, mask, style_bg, opa_scale);
320
        }
321
#endif
322

323

324
        /*Draw the indicator*/
325
        lv_area_t area_indic;
326
        lv_area_copy(&area_indic, &area_bg);
327

328
        /*Be sure at least ver pad/hor pad width indicator will remain*/
329
        lv_coord_t pad_ver_indic = style_indic->body.padding.ver;
330
        lv_coord_t pad_hor_indic = style_indic->body.padding.hor;
331
        if(pad_ver_indic * 2 + LV_SLIDER_SIZE_MIN > lv_area_get_height(&area_bg)) {
332
            pad_ver_indic = (lv_area_get_height(&area_bg) - LV_SLIDER_SIZE_MIN) >> 1;
333
        }
334
        if(pad_hor_indic * 2 + LV_SLIDER_SIZE_MIN > lv_area_get_width(&area_bg)) {
335
            pad_hor_indic = (lv_area_get_width(&area_bg) - LV_SLIDER_SIZE_MIN) >> 1;
336
        }
337

338
        area_indic.x1 += pad_hor_indic;
339
        area_indic.x2 -= pad_hor_indic;
340
        area_indic.y1 += pad_ver_indic;
341
        area_indic.y2 -= pad_ver_indic;
342

343

344
        lv_coord_t cur_value = lv_slider_get_value(slider);
345
        lv_coord_t min_value = lv_slider_get_min_value(slider);
346
        lv_coord_t max_value = lv_slider_get_max_value(slider);
347

348
        /*If dragged draw to the drag position*/
349
        if(ext->drag_value != LV_SLIDER_NOT_PRESSED) cur_value = ext->drag_value;
350

351
        if(slider_w >= slider_h) {
352
            area_indic.x2 = (int32_t)((int32_t)(lv_area_get_width(&area_indic)) * (cur_value - min_value)) / (max_value - min_value);
353
            area_indic.x2 = area_indic.x1 + area_indic.x2 - 1;
354

355
        } else {
356
            area_indic.y1 = (int32_t)((int32_t)(lv_area_get_height(&area_indic)) * (cur_value - min_value)) / (max_value - min_value);
357
            area_indic.y1 = area_indic.y2 - area_indic.y1 + 1;
358
        }
359

360
        if(cur_value != min_value) lv_draw_rect(&area_indic, mask, style_indic, opa_scale);
361

362
        /*Before the knob add the border if required*/
363
#if USE_LV_GROUP
364
        /* Draw the borders later if the bar is focused.
365
         * At value = 100% the indicator can cover to whole background and the focused style won't be visible*/
366
        if(lv_obj_is_focused(slider)) {
367
            lv_style_t style_tmp;
368
            lv_style_copy(&style_tmp, style_bg);
369
            style_tmp.body.empty = 1;
370
            style_tmp.body.shadow.width = 0;
371
            lv_draw_rect(&area_bg, mask, &style_tmp, opa_scale);
372
        }
373
#endif
374

375
        /*Draw the knob*/
376
        lv_area_t knob_area;
377
        lv_area_copy(&knob_area, &slider->coords);
378

379
        if(slider_w >= slider_h) {
380
            if(ext->knob_in == 0) {
381
                knob_area.x1 = area_indic.x2 - slider_h / 2;
382
                knob_area.x2 = knob_area.x1 + slider_h - 1;
383
            } else {
384
                knob_area.x1 = (int32_t)((int32_t)(slider_w - slider_h - 1) * (cur_value - min_value)) / (max_value - min_value);
385
                knob_area.x1 += slider->coords.x1;
386
                knob_area.x2 = knob_area.x1 + slider_h - 1;
387
            }
388

389
            knob_area.y1 = slider->coords.y1;
390
            knob_area.y2 = slider->coords.y2;
391
        } else {
392
            if(ext->knob_in == 0) {
393
                knob_area.y1 = area_indic.y1 - slider_w / 2;
394
                knob_area.y2 = knob_area.y1 + slider_w - 1;
395
            } else {
396
                knob_area.y2 = (int32_t)((int32_t)(slider_h - slider_w - 1) * (cur_value - min_value)) / (max_value - min_value);
397
                knob_area.y2 = slider->coords.y2 - knob_area.y2;
398
                knob_area.y1 = knob_area.y2 - slider_w - 1;
399
            }
400
            knob_area.x1 = slider->coords.x1;
401
            knob_area.x2 = slider->coords.x2;
402

403
        }
404
        lv_draw_rect(&knob_area, mask, style_knob, opa_scale);
405
    }
406
    /*Post draw when the children are drawn*/
407
    else if(mode == LV_DESIGN_DRAW_POST) {
408

409
    }
410

411
    return true;
412
}
413

414
/**
415
 * Signal function of the slider
416
 * @param slider pointer to a slider object
417
 * @param sign a signal type from lv_signal_t enum
418
 * @param param pointer to a signal specific variable
419
 * @return LV_RES_OK: the object is not deleted in the function; LV_RES_INV: the object is deleted
420
 */
421
static lv_res_t lv_slider_signal(lv_obj_t * slider, lv_signal_t sign, void * param)
422
{
423
    lv_res_t res;
424

425
    /* Include the ancient signal function */
426
    res = ancestor_signal(slider, sign, param);
427
    if(res != LV_RES_OK) return res;
428

429
    lv_slider_ext_t * ext = lv_obj_get_ext_attr(slider);
430
    lv_point_t p;
431
    lv_coord_t w = lv_obj_get_width(slider);
432
    lv_coord_t h = lv_obj_get_height(slider);
433

434
    if(sign == LV_SIGNAL_PRESSED) {
435
        ext->drag_value = lv_slider_get_value(slider);
436
    } else if(sign == LV_SIGNAL_PRESSING) {
437
        lv_indev_get_point(param, &p);
438
        int16_t tmp = 0;
439
        if(w > h) {
440
            lv_coord_t knob_w = h;
441
            p.x -= slider->coords.x1 + h / 2;    /*Modify the point to shift with half knob (important on the start and end)*/
442
            tmp = (int32_t)((int32_t) p.x * (ext->bar.max_value - ext->bar.min_value + 1)) / (w - knob_w);
443
            tmp += ext->bar.min_value;
444
        } else {
445
            lv_coord_t knob_h = w;
446
            p.y -= slider->coords.y1 + w / 2;    /*Modify the point to shift with half knob (important on the start and end)*/
447
            tmp = (int32_t)((int32_t) p.y * (ext->bar.max_value - ext->bar.min_value + 1)) / (h - knob_h);
448
            tmp = ext->bar.max_value - tmp;     /*Invert the value: smaller value means higher y*/
449
        }
450

451
        if(tmp < ext->bar.min_value) tmp = ext->bar.min_value;
452
        else if(tmp > ext->bar.max_value) tmp = ext->bar.max_value;
453

454
        if(tmp != ext->drag_value) {
455
            ext->drag_value = tmp;
456
            lv_obj_invalidate(slider);
457
            if(ext->action != NULL) res = ext->action(slider);
458
        }
459
    } else if(sign == LV_SIGNAL_RELEASED || sign == LV_SIGNAL_PRESS_LOST) {
460
        lv_slider_set_value(slider, ext->drag_value);
461
        ext->drag_value = LV_SLIDER_NOT_PRESSED;
462
        if(ext->action != NULL) res = ext->action(slider);
463
    } else if(sign == LV_SIGNAL_CORD_CHG) {
464
        /* The knob size depends on slider size.
465
         * During the drawing method the ext. size is used by the knob so refresh the ext. size.*/
466
        if(lv_obj_get_width(slider) != lv_area_get_width(param) ||
467
                lv_obj_get_height(slider) != lv_area_get_height(param)) {
468
            slider->signal_func(slider, LV_SIGNAL_REFR_EXT_SIZE, NULL);
469
        }
470
    } else if(sign == LV_SIGNAL_REFR_EXT_SIZE) {
471
        lv_style_t * style = lv_slider_get_style(slider, LV_SLIDER_STYLE_BG);
472
        lv_style_t * knob_style = lv_slider_get_style(slider, LV_SLIDER_STYLE_KNOB);
473
        lv_coord_t shadow_w = knob_style->body.shadow.width;
474
        if(ext->knob_in == 0) {
475
            /* The smaller size is the knob diameter*/
476
            lv_coord_t x = LV_MATH_MIN(w / 2 + 1 + shadow_w, h / 2 + 1 + shadow_w);
477
            if(slider->ext_size < x) slider->ext_size = x;
478
        } else {
479
            lv_coord_t pad = LV_MATH_MIN(style->body.padding.hor, style->body.padding.ver);
480
            if(pad < 0) pad = -pad;
481
            if(slider->ext_size < pad) slider->ext_size = pad;
482

483
            if(slider->ext_size < shadow_w) slider->ext_size = shadow_w;
484
        }
485
    } else if(sign == LV_SIGNAL_CONTROLL) {
486
        char c = *((char *)param);
487

488
        ext->drag_value = LV_SLIDER_NOT_PRESSED;
489

490
#if USE_LV_GROUP
491
        lv_group_t * g = lv_obj_get_group(slider);
492
        bool editing = lv_group_get_editing(g);
493
        lv_hal_indev_type_t indev_type = lv_indev_get_type(lv_indev_get_act());
494
        /*Encoders need special handling*/
495
        if(indev_type == LV_INDEV_TYPE_ENCODER && c == LV_GROUP_KEY_ENTER) {
496
            if(editing) lv_group_set_editing(g, false);
497
        }
498
#endif
499
        if(c == LV_GROUP_KEY_RIGHT || c == LV_GROUP_KEY_UP) {
500
            lv_slider_set_value(slider, lv_slider_get_value(slider) + 1);
501
            if(ext->action != NULL) res = ext->action(slider);
502
        } else if(c == LV_GROUP_KEY_LEFT || c == LV_GROUP_KEY_DOWN) {
503
            lv_slider_set_value(slider, lv_slider_get_value(slider) - 1);
504
            if(ext->action != NULL) res = ext->action(slider);
505
        }
506
    } else if(sign == LV_SIGNAL_GET_EDITABLE) {
507
        bool * editable = (bool *)param;
508
        *editable = true;
509
    } else if(sign == LV_SIGNAL_GET_TYPE) {
510
        lv_obj_type_t * buf = param;
511
        uint8_t i;
512
        for(i = 0; i < LV_MAX_ANCESTOR_NUM - 1; i++) {  /*Find the last set data*/
513
            if(buf->type[i] == NULL) break;
514
        }
515
        buf->type[i] = "lv_slider";
516
    }
517

518
    return res;
519
}
520
#endif
521

522