long touch detect on STM32L4R9AI-eval

A way of doing that is to create a button class that allows you to receive an event on both press and release action. Then, you just implement the handleTickEvent() in your screenView. As @Martin KJELDSEN​ mentioned, referring to Button, AbstractButton and at the code generated when creating a FlexButton in the Designer can help you considerably.

Here is a possible version :

customButtonContainer.hpp

#ifndef CUSTOMBUTTONCONTAINER_HPP
#define CUSTOMBUTTONCONTAINER_HPP
 
#include <touchgfx/containers/Container.hpp>
#include <touchgfx/widgets/Image.hpp>
 
namespace touchgfx
{
/**
 * @class CustomButtonTrigger CustomButtonTrigger.hpp
 */
class CustomButtonContainer : public Container
{
public:
 
 /**
 * @fn CustomButtonContainer::CustomButtonContainer()
 *
 * @brief Default constructor.
 */
 CustomButtonContainer() : pressed(false), alpha(255), up(), down(), action(0)
 {
 setTouchable(true);
 buttonImage.setXY(0, 0);
 add(buttonImage);
 }
 
 /**
 * @fn virtual CustomButtonContainer::~CustomButtonContainer()
 *
 * @brief Destructor.
 */
 virtual ~CustomButtonContainer() {}
 
 /**
 * @fn virtual void CustomButtonContainer::setBitmaps(const Bitmap& bmpReleased, const Bitmap& bmpPressed)
 *
 * @brief Sets the bitmaps.
 *
 * @param bmpReleased The bitmap released.
 * @param bmpPressed The bitmap pressed.
 */
 virtual void setBitmaps(const Bitmap& bmpReleased, const Bitmap& bmpPressed)
 {
 up = bmpReleased;
 down = bmpPressed;
 setWidth(down.getWidth());
 setHeight(down.getHeight());
 
 handlePressedUpdated();
 }
 
 /**
 * @fn void CustomButtonContainer::setBitmapXY(uint16_t x, uint16_t y)
 *
 * @brief Sets bitmap xy.
 *
 * @param x An uint16_t to process.
 * @param y An uint16_t to process.
 */
 void setBitmapXY(uint16_t x, uint16_t y)
 {
 buttonImage.setXY(x, y);
 }
 
 /**
 * @fn Bitmap CustomButtonContainer::getCurrentlyDisplayedBitmap() const
 *
 * @brief Gets currently displayed bitmap.
 *
 * @return The currently displayed bitmap.
 */
 Bitmap getCurrentlyDisplayedBitmap() const
 {
 return (pressed ? down : up);
 }
 
 /**
 * @fn void CustomButtonContainer::setPressed(bool isPressed)
 *
 * @brief Sets the pressed state.
 *
 * @param isPressed True if is pressed, false if not.
 */
 void setPressed(bool isPressed)
 {
 pressed = isPressed;
 handlePressedUpdated();
 }
 
 /**
 * @fn bool CustomButtonContainer::getPressed()
 *
 * @brief Gets the pressed state.
 *
 * @return True if it succeeds, false if it fails.
 */
 bool getPressed()
 {
 return pressed;
 }
 
 /**
 * @fn void CustomButtonContainer::setAlpha(uint8_t newAlpha)
 *
 * @brief Sets an alpha value.
 *
 * @param newAlpha The new alpha.
 */
 void setAlpha(uint8_t newAlpha)
 {
 alpha = newAlpha;
 handleAlphaUpdated();
 }
 
 /**
 * @fn uint8_t CustomButtonContainer::getAlpha() const
 *
 * @brief Gets the alpha.
 *
 * @return The alpha value.
 */
 uint8_t getAlpha() const
 {
 return alpha;
 }
 
 /**
 * @fn void CustomButtonContainer::setAction(GenericCallback< const CustomButtonContainer&, bool& >& callback)
 *
 * @brief Sets an action callback.
 *
 * @param callback The callback.
 */
 void setAction(GenericCallback< const CustomButtonContainer&, bool& >& callback)
 {
 action = &callback;
 }
 
 /**
 * @fn virtual void CustomButtonContainer::handleClickEvent(const ClickEvent& event)
 *
 * @brief Handles the click event described by event.
 *
 * @param event The event.
 */
 virtual void handleClickEvent(const ClickEvent& event)
 {
 bool wasPressed = getPressed();
 bool newPressedValue = (event.getType() == ClickEvent::PRESSED);
 if ((newPressedValue && !wasPressed) || (!newPressedValue && wasPressed))
 {
 setPressed(newPressedValue);
 invalidate();
 if (action->isValid())
 {
 action->execute(*this, pressed);
 }
 }
 }
 
 
protected:
 bool pressed; ///< True if pressed
 uint8_t alpha; ///< The current alpha value. 255 denotes solid, 0 denotes completely transparent.
 Image buttonImage; ///< The button image
 Bitmap up; ///< The image to display when button is released.
 Bitmap down; ///< The image to display when button is pressed.
 
 GenericCallback< const CustomButtonContainer&, bool&>* action; ///< The action
 
 /**
 * @fn virtual void CustomButtonContainer::handlePressedUpdated()
 *
 * @brief Handles the pressed updated.
 */
 virtual void handlePressedUpdated() 
 {
 buttonImage.setBitmap(pressed ? down : up);
 }
 
 /**
 * @fn virtual void CustomButtonContainer::handleAlphaUpdated()
 *
 * @brief Handles the alpha updated.
 */
 virtual void handleAlphaUpdated()
 {
 buttonImage.setAlpha(alpha);
 }
};
 
 
} // namespace touchgfx
 
#endif // CUSTOMBUTTONCONTAINER_HPP

Screen1View.hpp

#ifndef SCREEN1VIEW_HPP
#define SCREEN1VIEW_HPP
 
#include <gui_generated/screen1_screen/Screen1ViewBase.hpp>
#include <gui/screen1_screen/Screen1Presenter.hpp>
#include <gui/common/customButtonContainer.hpp>
 
class Screen1View : public Screen1ViewBase
{
public:
 Screen1View();
 virtual ~Screen1View() {}
 virtual void setupScreen();
 virtual void tearDownScreen();
 
 virtual void handleTickEvent();
protected:
 touchgfx::CustomButtonContainer customButton1, customButton2;
 
 uint16_t counter;
 bool buttonPressedFlag;
 
 Callback<Screen1View, const CustomButtonContainer&, bool&> buttonEventCallback;
 
 void handleButtonEvent(const CustomButtonContainer& element, bool& buttonState);
};
 
#endif // SCREEN1VIEW_HPP

Screen1View.cpp

#include <gui/screen1_screen/Screen1View.hpp>
#include "BitmapDatabase.hpp"
 
Screen1View::Screen1View():
 counter(0),
 buttonPressedFlag(false),
 buttonEventCallback(this, &Screen1View::handleButtonEvent)
{
 customButton1.setBitmaps(Bitmap(BITMAP_BLUE_BUTTONS_ROUND_EDGE_MEDIUM_ID), Bitmap(BITMAP_BLUE_BUTTONS_ROUND_EDGE_MEDIUM_PRESSED_ID));
 customButton1.setBitmapXY(0, 0);
 customButton1.setPosition(285, 200, 230, 60);
 
 customButton2.setBitmaps(Bitmap(BITMAP_BLUE_BUTTONS_ROUND_EDGE_MEDIUM_ID), Bitmap(BITMAP_BLUE_BUTTONS_ROUND_EDGE_MEDIUM_PRESSED_ID));
 customButton2.setBitmapXY(0, 0);
 customButton2.setPosition(20, 20, 230, 60);
 
 add(customButton1);
 add(customButton2);
 
 customButton1.setAction(buttonEventCallback);
 customButton2.setAction(buttonEventCallback);
}
 
void Screen1View::setupScreen()
{
 Screen1ViewBase::setupScreen();
}
 
void Screen1View::tearDownScreen()
{
 Screen1ViewBase::tearDownScreen();
}
 
void Screen1View::handleButtonEvent(const CustomButtonContainer& element, bool& buttonState)
{
 if(buttonState)
 {
 if(&element == &customButton1)
 {
 touchgfx_printf("pressed 1\n");
 buttonPressedFlag = true;
 }
 else if(&element == &customButton2)
 {
 touchgfx_printf("pressed 2\n");
 }
 }
 else
 {
 if(&element == &customButton1)
 {
 touchgfx_printf("released 1\n");
 buttonPressedFlag = false;
 counter = 0;
 }
 else if(&element == &customButton2)
 {
 touchgfx_printf("released 2\n");
 }
 }
}
 
void Screen1View::handleTickEvent()
{
 if(buttonPressedFlag)
 {
 counter++;
 if(counter%180 == 0) // 3 seconds has passed
 {
 //move to another screen
 }
 }
}

/Alexandre