LVGL-输入设备LV_INDEV_TYPE_POINTER类型

已于 2022-03-16 14:49:43 修改
阅读量956 收藏
点赞数
文章标签： ui c++ mcu
于 2022-03-10 22:15:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47620452/article/details/123406926
版权

void _lv_indev_read_task(lv_task_t * task)是定时执行的输入设备任务回调函数。会处理输入设备的数据。

按下的处理：

        static void indev_proc_press(lv_indev_proc_t * proc)

        {

        ……

        *首先从layer_sys，layer_top，scr_act按优级查找当前的活动对象

       /* bool lv_obj_is_point_on_coords(lv_obj_t * obj, const lv_point_t * point)*/

        indev_obj_act = lv_indev_search_obj(lv_disp_get_layer_sys(disp),         &proc->types.pointer.act_point);

        if(indev_obj_act == NULL) indev_obj_act =         lv_indev_search_obj(lv_disp_get_layer_top(disp),
                                                                          &proc->types.pointer.act_point);
        if(indev_obj_act == NULL) indev_obj_act = lv_indev_search_obj(lv_disp_get_scr_act(disp),
                                                                          &proc->types.pointer.act_point);
        new_obj_searched = true;

        ……

        *如果按下时有throw动作手动停止。page drag后一般有throw动作。

            /*The last object might have drag throw. Stop it manually*/
            if(new_obj_searched && proc->types.pointer.last_obj) {
                proc->types.pointer.drag_throw_vect.x = 0;
                proc->types.pointer.drag_throw_vect.y = 0;
                indev_drag_throw(proc);
            }

        ……

        *如果当前的活动对与上一次的活动对象不一样。proc->types.pointer.act_obj是上一次的活动  对象，通知上一个活动对象PRESS_LOST（1次）。通知最近的对象被PRESSED(1次)，并复位一些寄存器。

    /*If a new object was found reset some variables and send a pressed signal*/
    if(indev_obj_act != proc->types.pointer.act_obj) {
        /*刚选中的活动对象不产生坐标向量值，把last_point与act_point同步*/
        proc->types.pointer.last_point.x = proc->types.pointer.act_point.x;
        proc->types.pointer.last_point.y = proc->types.pointer.act_point.y;

        /*If a new object found the previous was lost, so send a signal*/
        if(proc->types.pointer.act_obj != NULL) {
            /*Save the obj because in special cases `act_obj` can change in the signal function*/
            lv_obj_t * last_obj = proc->types.pointer.act_obj;

            last_obj->signal_cb(last_obj, LV_SIGNAL_PRESS_LOST, indev_act);
            if(indev_reset_check(proc)) return;
            lv_event_send(last_obj, LV_EVENT_PRESS_LOST, NULL);
            if(indev_reset_check(proc)) return;

        }

        proc->types.pointer.act_obj  = indev_obj_act; /*Save the pressed object*/
        proc->types.pointer.last_obj = indev_obj_act;

        if(indev_obj_act != NULL) {
            /* Save the time when the obj pressed to count long press time.*/
            proc->pr_timestamp                 = lv_tick_get();
            proc->long_pr_sent                 = 0;
            proc->types.pointer.drag_limit_out = 0;
            proc->types.pointer.drag_in_prog   = 0;
            proc->types.pointer.drag_sum.x     = 0;
            proc->types.pointer.drag_sum.y     = 0;
            proc->types.pointer.drag_dir = LV_DRAG_DIR_BOTH;
            proc->types.pointer.gesture_sent   = 0;
            proc->types.pointer.gesture_sum.x  = 0;
            proc->types.pointer.gesture_sum.y  = 0;
            proc->types.pointer.vect.x         = 0;
            proc->types.pointer.vect.y         = 0;

            /*Search for 'top' attribute*/
            lv_obj_t * i        = indev_obj_act;
            lv_obj_t * last_top = NULL;
            while(i != NULL) {
                if(i->top) last_top = i;
                i = lv_obj_get_parent(i);
            }

            if(last_top != NULL) {
                /*Move the last_top object to the foreground*/
                lv_obj_move_foreground(last_top);
            }

            /*Send a signal about the press*/
            indev_obj_act->signal_cb(indev_obj_act, LV_SIGNAL_PRESSED, indev_act);
            if(indev_reset_check(proc)) return;

            lv_event_send(indev_obj_act, LV_EVENT_PRESSED, NULL);
            if(indev_reset_check(proc)) return;

            if(indev_act->proc.wait_until_release) return;

            /*Handle focus*/
            indev_click_focus(&indev_act->proc);
            if(indev_reset_check(proc)) return;

        }
    }

        *构建drag_throw_vect（throw效果的向量）与vect（两次坐标输入向量）的相关性，方便释放时使用。

    ……
    /*Calculate the types.pointer.vector*/
    proc->types.pointer.vect.x = proc->types.pointer.act_point.x - proc->types.pointer.last_point.x;
    proc->types.pointer.vect.y = proc->types.pointer.act_point.y - proc->types.pointer.last_point.y;

    proc->types.pointer.drag_throw_vect.x = (proc->types.pointer.drag_throw_vect.x * 5) >> 3;
    proc->types.pointer.drag_throw_vect.y = (proc->types.pointer.drag_throw_vect.y * 5) >> 3;

    if(proc->types.pointer.drag_throw_vect.x < 0)
        proc->types.pointer.drag_throw_vect.x++;
    else if(proc->types.pointer.drag_throw_vect.x > 0)
        proc->types.pointer.drag_throw_vect.x--;

    if(proc->types.pointer.drag_throw_vect.y < 0)
        proc->types.pointer.drag_throw_vect.y++;
    else if(proc->types.pointer.drag_throw_vect.y > 0)
        proc->types.pointer.drag_throw_vect.y--;

    proc->types.pointer.drag_throw_vect.x += (proc->types.pointer.vect.x * 4) >> 3;
    proc->types.pointer.drag_throw_vect.y += (proc->types.pointer.vect.y * 4) >> 3;
    ……

        *处理拖动、手势、长按、重复长按。PRESSING信号会一直发送。

    /*If there is active object and it can be dragged run the drag*/
    if(indev_obj_act != NULL) 
    {
        indev_obj_act->signal_cb(indev_obj_act, LV_SIGNAL_PRESSING, indev_act);
        if(indev_reset_check(proc)) return;
        lv_event_send(indev_obj_act, LV_EVENT_PRESSING, NULL);
        if(indev_reset_check(proc)) return;
        if(indev_act->proc.wait_until_release) return;

        indev_drag(proc);
        indev_gesture(proc);
        if(indev_reset_check(proc)) return;

        /*If there is no drag then check for long press time*/
        if(proc->types.pointer.drag_in_prog == 0 && proc->long_pr_sent == 0) 
        {
            /*Send a signal about the long press if enough time elapsed*/
            if(lv_tick_elaps(proc->pr_timestamp) >                 indev_act->driver.long_press_time)                                  
            {
                indev_obj_act->signal_cb(indev_obj_act, LV_SIGNAL_LONG_PRESS, indev_act);
                if(indev_reset_check(proc)) return;
                lv_event_send(indev_obj_act, LV_EVENT_LONG_PRESSED, NULL);
                if(indev_reset_check(proc)) return;

                /*Mark the signal sending to do not send it again*/
                proc->long_pr_sent = 1;

                /*Save the long press time stamp for the long press repeat handler*/
                proc->longpr_rep_timestamp = lv_tick_get();
            }
        }
        /*Send long press repeated signal*/
        if(proc->types.pointer.drag_in_prog == 0 && proc->long_pr_sent == 1) 
        {
            /*Send a signal about the long press repeat if enough time elapsed*/
            if(lv_tick_elaps(proc->longpr_rep_timestamp) > indev_act->driver.long_press_rep_time) 
            {
                indev_obj_act->signal_cb(indev_obj_act, LV_SIGNAL_LONG_PRESS_REP, indev_act);
                if(indev_reset_check(proc)) return;
                lv_event_send(indev_obj_act, LV_EVENT_LONG_PRESSED_REPEAT, NULL);
                if(indev_reset_check(proc)) return;
                proc->longpr_rep_timestamp = lv_tick_get();
            }
        }
    }

   *indev_drag有两个变量，proc->types.pointer.drag_limit_out全局变量开启拖累后会一直为1，切到新对象才到写0。drag_just_started局部变量与limit_out同时置位控制方向，DRAG_BEGIN信号发送。

static void indev_drag(lv_indev_proc_t * proc)
{
    lv_obj_t * drag_obj    = get_dragged_obj(proc->types.pointer.act_obj);
    bool drag_just_started = false;
    uint8_t drag_dir; //saimen

    if(drag_obj == NULL) return;

    if(lv_obj_get_drag(drag_obj) == false) return;

    lv_drag_dir_t allowed_dirs = lv_obj_get_drag_dir(drag_obj);

    /*Count the movement by drag*/
    if(proc->types.pointer.drag_limit_out == 0) {
        proc->types.pointer.drag_sum.x += proc->types.pointer.vect.x;
        proc->types.pointer.drag_sum.y += proc->types.pointer.vect.y;

        /*Enough move?*/
        bool hor_en = false;
        bool ver_en = false;
        if(allowed_dirs == LV_DRAG_DIR_HOR || allowed_dirs == LV_DRAG_DIR_BOTH) {
            hor_en = true;
        }

        if(allowed_dirs == LV_DRAG_DIR_VER || allowed_dirs == LV_DRAG_DIR_BOTH ||\
           allowed_dirs == LV_DRAG_DIR_VER_ONLY_UP || allowed_dirs == LV_DRAG_DIR_VER_ONLY_DOWN) {
            ver_en = true;
        }

        if(allowed_dirs == LV_DRAG_DIR_ONE) {
            if(LV_MATH_ABS(proc->types.pointer.drag_sum.x) > LV_MATH_ABS(proc->types.pointer.drag_sum.y)) {
                hor_en = true;
                drag_dir = 0x10;
            }
            else {
                ver_en = true;
                drag_dir = 0x20;
            }
        }

        /*If a move is greater then LV_DRAG_LIMIT then begin the drag*/
        if((hor_en && LV_MATH_ABS(proc->types.pointer.drag_sum.x) >= indev_act->driver.drag_limit) ||
           (ver_en && LV_MATH_ABS(proc->types.pointer.drag_sum.y) >= indev_act->driver.drag_limit)) {
            proc->types.pointer.drag_limit_out = 1;
            drag_just_started                   = true;
            if(drag_dir==0x10)
            {
                if(proc->types.pointer.drag_sum.x>0)
                {
                    drag_dir |= 1;
                }
                else
                {
                    drag_dir |= 2;
                }
            }
            else
            {
                if(proc->types.pointer.drag_sum.y>0)
                {
                    drag_dir |= 1;
                }
                else
                {
                    drag_dir |= 2;
                }
            }
        }
    }

    /*If the drag limit is exceeded handle the dragging*/
    if(proc->types.pointer.drag_limit_out != 0) {
        /*Set new position if the vector is not zero*/
        if(proc->types.pointer.vect.x != 0 || proc->types.pointer.vect.y != 0) {

            lv_coord_t prev_x     = drag_obj->coords.x1;
            lv_coord_t prev_y     = drag_obj->coords.y1;
            lv_coord_t prev_par_w = lv_obj_get_width(lv_obj_get_parent(drag_obj));
            lv_coord_t prev_par_h = lv_obj_get_height(lv_obj_get_parent(drag_obj));

            /*Get the coordinates of the object and modify them*/
            lv_coord_t act_x = lv_obj_get_x(drag_obj);
            lv_coord_t act_y = lv_obj_get_y(drag_obj);

            if(allowed_dirs == LV_DRAG_DIR_BOTH) {
                if(drag_just_started) {
                    proc->types.pointer.drag_dir = LV_DRAG_DIR_BOTH;
                    act_x += proc->types.pointer.drag_sum.x;
                    act_y += proc->types.pointer.drag_sum.y;
                }
            }
            else if(allowed_dirs == LV_DRAG_DIR_HOR) {
                if(drag_just_started) {
                    proc->types.pointer.drag_dir = LV_DRAG_DIR_HOR;
                    proc->types.pointer.drag_sum.y = 0;
                    act_x += proc->types.pointer.drag_sum.x;
                }
            }
            else if(allowed_dirs == LV_DRAG_DIR_VER) {
                if(drag_just_started) {
                    proc->types.pointer.drag_dir = LV_DRAG_DIR_VER;
                    proc->types.pointer.drag_sum.x = 0;
                    act_y += proc->types.pointer.drag_sum.y;
                }
            }
            else if(allowed_dirs == LV_DRAG_DIR_ONE) {
                if(drag_just_started) {
                    if(LV_MATH_ABS(proc->types.pointer.drag_sum.x) > LV_MATH_ABS(proc->types.pointer.drag_sum.y)) {
                        proc->types.pointer.drag_dir = LV_DRAG_DIR_HOR;
                        proc->types.pointer.drag_sum.y = 0;
                        act_x += proc->types.pointer.drag_sum.x;
                    }
                    else {
                        proc->types.pointer.drag_dir = LV_DRAG_DIR_VER;
                        proc->types.pointer.drag_sum.x = 0;
                        act_y += proc->types.pointer.drag_sum.y;
                    }
                }
            }
            else if (allowed_dirs == LV_DRAG_DIR_VER_ONLY_UP) {
                if (drag_just_started) {
                    proc->types.pointer.drag_dir = LV_DRAG_DIR_VER;
                    proc->types.pointer.drag_sum.x = 0;
                    if (act_y + proc->types.pointer.drag_sum.y <= 0)
                        act_y += proc->types.pointer.drag_sum.y;
                    else
                        proc->types.pointer.drag_sum.y = 0;
                }
            }
            else if (allowed_dirs == LV_DRAG_DIR_VER_ONLY_DOWN) {
                if (drag_just_started) {
                    proc->types.pointer.drag_dir = LV_DRAG_DIR_VER;
                    proc->types.pointer.drag_sum.x = 0;
                    if (act_y + proc->types.pointer.drag_sum.y >= 0)
                        act_y += proc->types.pointer.drag_sum.y;
                    else
                        proc->types.pointer.drag_sum.y = 0;
                }
            }
            

            /*Move the object*/
            if(allowed_dirs == LV_DRAG_DIR_HOR ||
               allowed_dirs == LV_DRAG_DIR_BOTH ||
               (allowed_dirs == LV_DRAG_DIR_ONE &&
                LV_MATH_ABS(proc->types.pointer.drag_sum.x) > LV_MATH_ABS(proc->types.pointer.drag_sum.y))) {
                act_x += proc->types.pointer.vect.x;
            }
            if(allowed_dirs == LV_DRAG_DIR_VER ||
               allowed_dirs == LV_DRAG_DIR_BOTH ||
               (allowed_dirs == LV_DRAG_DIR_ONE &&
                LV_MATH_ABS(proc->types.pointer.drag_sum.x) < LV_MATH_ABS(proc->types.pointer.drag_sum.y))) {
                act_y += proc->types.pointer.vect.y;
            }
            if (allowed_dirs == LV_DRAG_DIR_VER_ONLY_UP)
            {
                if (act_y + proc->types.pointer.vect.y <= 0)
                    act_y += proc->types.pointer.vect.y;
            }
            if (allowed_dirs == LV_DRAG_DIR_VER_ONLY_DOWN)
            {
                if (act_y + proc->types.pointer.vect.y >= 0)
                    act_y += proc->types.pointer.vect.y;
            }

            uint16_t inv_buf_size =
                lv_disp_get_inv_buf_size(indev_act->driver.disp); /*Get the number of currently invalidated areas*/

            lv_obj_set_pos(drag_obj, act_x, act_y);
            proc->types.pointer.drag_in_prog = 1;

            /*If the object didn't moved then clear the invalidated areas*/
            if(drag_obj->coords.x1 == prev_x && drag_obj->coords.y1 == prev_y) {
                /*In a special case if the object is moved on a page and
                 * the scrollable has fit == true and the object is dragged of the page then
                 * while its coordinate is not changing only the parent's size is reduced */
                lv_coord_t act_par_w = lv_obj_get_width(lv_obj_get_parent(drag_obj));
                lv_coord_t act_par_h = lv_obj_get_height(lv_obj_get_parent(drag_obj));
                if(act_par_w == prev_par_w && act_par_h == prev_par_h) {
                    uint16_t new_inv_buf_size = lv_disp_get_inv_buf_size(indev_act->driver.disp);
                    _lv_disp_pop_from_inv_buf(indev_act->driver.disp, new_inv_buf_size - inv_buf_size);
                }
            }

            /*Set the drag in progress flag*/
            /*Send the drag begin signal on first move*/
            if(drag_just_started) {
                drag_obj->signal_cb(drag_obj, LV_SIGNAL_DRAG_BEGIN, indev_act);
                if(indev_reset_check(proc)) return;

                //lv_event_send(drag_obj, LV_EVENT_DRAG_BEGIN, NULL);
                lv_event_send(drag_obj, LV_EVENT_DRAG_BEGIN, &drag_dir);
                if(indev_reset_check(proc)) return;
            }

        }
    }
}

*indev_drag中的通过调用void lv_obj_set_pos()来改变坐标，触发滚动传输。第次坐标的改变都会通知到父、子对象还有自已。

释放的处理：

static void indev_proc_release(lv_indev_proc_t * proc)

等一下写



 

sailing-data
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
lvgl使用旋转编码器(EC11)做为输入设备，使用单色OLED做为显示设备。
06-25
用的单色OLED屏显示，不得不说，使用单色屏幕的话，有些控件不能正常显示，需要自己额外设定一下，而且对于有动态变化的控件来说更是如此，比如按钮，在彩色屏幕下正常添加一个按钮按下时会有按下的动态效果，而在单色屏幕下就需要额外设置。还有开关等，可能都需要额外设置。对于只是起显示作用的控件来说影响不大，标签，图表，线条等。写了一个界面，其中包含两个按钮，使用编码器进行选择。
《ESP32-Arduino》LVGL之输入设备详解及实例(触摸屏,实体按键,编码器,多功能按键)
热门推荐
MGodmonkey的专属博客
03-01 1万+
LVGL之输入设备详解及实例(触摸屏,实体按键,编码器,多功能按键)
LVGL官方文档-7.11.0-5-Porting-Input device interface
我是Timothy
07-16 599
Types of input devices 配置输入设备的时候，需要初始化一个lv_indev_drv_t类型的变量： lv_indev_drv_t indev_drv; lv_indev_drv_init(&indev_drv); /*Basic initialization*/ indev_drv.type =... /*See below.*/ indev_drv.read_cb =... /*See below.*/ /*
LVGL的基础知识总结
最新发布
qq_28576837的博客
02-29 1439
另外，还有自定义字库的使用，具体可参考开发手册。
LVGL学习笔记6 - 输入设备
pq的博客
12-28 5546
输入设备的回调函数需要用户根据硬件自己实现，例如上例中的lv_win32_pointer_driver_read_callback、lv_win32_keypad_driver_read_callback和lv_win32_encoder_driver_read_callback。通过lv_obj_add_event_cb给对象添加事件处理程序函数。filter - 事件代码，例如LV_EVENT_CLICKED表示点击事件，具体可以看lv_event.h中的枚举lv_event_code_t。
LVGL使用指定的输入设备控制
beile759的博客
12-17 593
介绍在第二节中，我添加了按键的输入设备，其实其他输入设备也是一样，这次我们将输入设备应用到我们的屏幕中，用来控制控件的选中和控制。大家先去看第二篇文章，移植了按钮输入设备，再来看本文章。
LVGL学习(4)：输入设备的四种类型及物理按键的实现
主要分享硬件、嵌入式软件部分知识
06-07 4672
在有一些场合中，如野外情况，可能我们会选择使用物理按键来控制LVGL，而不是使用触摸屏。所以本篇文章就以物理键盘为例来介绍一下如何自定义输入设备与LVGL进行交互。
LVGL-输入设备
qq_27762339的博客
07-09 974
LVGL 输入设备
lvgl-master_exact6od_lvgl编程_lv_conf_checker.h_lvgl开发环境_lvql_
10-02
微型的GUI库，使用与STM32与C51系列的单片机，功能强大
LVGL配置文件详解lv_conf.h（V7.9.1）.pdf
03-18
lvgl，即Light and Versatile Graphics Library，是一个开源的图形库，可以运行在各类单片机上，在使用时需要配置lv_conf.h文件对lvgl配置和剪裁，本文对lv_conf.h进行的全方位的解读
基于vs2019的lvgl模拟器lv_sim_visual_studio_sdl
03-19
基于vs2019的lvgl模拟器lv_sim_visual_studio_sdl lv_sim_visual_studio_sdl（lv_port_win_visual_studio） 需要依赖于：lvgl、lv_drivers、freetype。 （1）lv_port_win_visual_studio-master.zip （2）...
lvgl_v8_sim_codeblocks_win-master.zip
08-25
windows下codeblocks模拟运行lvgl8
lv_examples：LVGL嵌入式GUI库的示例，教程和应用程序
02-12
LVGL的例子 在这里，您可以找到LVGL嵌入式GUI库的示例和演示。 将示例添加到您的项目中 克隆此存储库： git clone https://github.com/lvgl/lv_examples.git 。 lv_examples目录应位于项目中lvgl目录的旁边。 与lv...
lvgl lv_indev_t （一）之 _lv_indev_drv_t 解读
u014437906的博客
09-29 1702
LVGL lv_indev_t 解读
LVGL 获取光标坐标位置
sflyhx的博客
10-31 1967
为了方便获取物理按键输入的坐标，在仿真时直接开启打印坐标显示，获取自己想要的坐标。
ESP32系列之LVGL（四）：输入设备（外部按键）对接
m0_55986987的博客
09-27 2869
lvgl 按键输入
项目经验分享：LVGL编程举例
Donald_Shallwing的博客
05-31 6932
与绝大多数GUI组件相似，LVGL的GUI组件主要包括Lable（标签）、Button（按键）、Image（图片）、Image Button（图片按钮）、Keyboard（键盘）、Calendar（日历表）、Chart（数据表）等。LVGL中所有的组件对象都是由lv_obj_t来定义的，并通过对应的组件创建函数lv_XXX_create来创建相关的对象。lv_scr_act()表示对组件赋予显示功能。
lvgl lv_indev_t 之 _lv_indev_proc_t解读
u014437906的博客
09-29 824
lv_indev_proc 解读
LVGL 的 LV_EVENT_GESTURE
weixin_46964996的博客
09-22 1574
LV_EVENT_GESTURE lv_indev_wait_release()
LVGL中输入设备LV_INDEV_TYPE_POINTER类型怎么添加鼠标右键
05-25
在LVGL中，可以通过 `lv_indev_set_button_id()` 函数来为输入设备设置不同的按键ID。对于鼠标，一般会使用 `LV_INDEV_STATE_BTN1` 表示左键，`LV_INDEV_STATE_BTN2` 表示中键，`LV_INDEV_STATE_BTN3` 表示右键。因此，如果想要添加鼠标右键支持，你可以在初始化输入设备后，通过以下代码来设置右键的按键ID： ```c lv_indev_set_button_id(indev, LV_INDEV_STATE_BTN3, 2); // 设置右键按键ID为2 ``` 这样，在使用鼠标时，当检测到右键按下事件时，将会触发 `LV_EVENT_PRESSED` 事件，并且可以通过 `lv_event_get_data()` 函数获取到按下的按键ID。你可以根据需要在事件回调函数中进行处理，例如： ```c static void mouse_event_cb(lv_obj_t * obj, lv_event_t event) { lv_indev_t * indev = lv_indev_get_act(); if (indev == NULL) return; if (event == LV_EVENT_PRESSED) { uint32_t btn_id = lv_event_get_data(); if (btn_id == 2) { // 右键按下 // 处理右键按下事件 } } } ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值