Animating Form Transitions on Touchscreen Swipe Similar to Smart Phones

[colorplace]

INTRO
-----

I am developing an industrial application for Linux embedded which will run on an 800 x 400 LCD touch screen display. There are 4 external pushbuttons

that will be used to drive the application in addition to the touch screen similar to modern smart phones (Home, Back, Help, and Menu). The embedded

platform is not yet finalized, but we are thinking about using an Atom based processor for embedded Linux running at maybe 1 GHz. The application is a

conventional desktop application as opposed to a graphics based application, although we will likely need 2D graphing support.

The application software is currently a 4 tiered sequence, beginning with a home icon screen, where selections make visible a secondary level of icon

screens. Upon selection of an icon from the secondary screen, a list view is displayed. When an item is selected for the list view, an editor specific

to the list view type is displayed. The editors are dynamic and include content for editing text, numeric, boolean, conditional lists, and running a

method.

I am currently using QCreator/Qt/C++ for the development. The architecture of the current application is based on QStackedWidgets. The main window

contains a header and footer which are present for all views. The client area of the main window has swappable content that is programmatically

controlled based on the user selections from the icon screens.

This client area inscribed by the persistent header and footer consists of QStackedWidgets, which can also bring up a widget that contains

QStackedWidgets, as is the case for the variable editors. Edit stack widget content is created as a separate form in
QtDesigner and are all based on QWidget.

The list view shown requires multiline content as shown in my current implementation. It is currently driven by the mouse to implement scrolling for a

touch screen. It would be desirable to implement kinetic scrolling, over scroll indications, and perhaps bouncing (not a hard requirement). I have

looked at the "Flick Charm" project for a possible enhancement to my current implementation.


QUESTION #1: Sliding Window Architecture and Animations.
-----------

I am reviewing the existing application architecture relative to the requirement of having animated transitions between screens. We have a requirement to

show screen transitions in a slide manner of a left and right scroll (similar to the IPhone or Android platforms).

Eventually, I need to have a home screen, and swipes on the touch screen in one of four directions (up, down, right, left) need to slide to reveal the

other screens. Navigation back to the home screen would be the reverse of the action taken to navigate out of the home screen. This is similar to

modern smart phones.

How would one architect such an application, presumably in QTCreator and what Qt classes would be most applicable. For example, to achieve a home screen

which can be slide in one of four directions, would it be advisable to create on larger monster screen, and the action of sliding would reveal other

content? It would be preferable to develop the individual screen content separately and then perhaps knit them together in the application code.

I have reviewed the QPropertyAnimation class, and was wondering if it would be applicable for animating the position of entire form
composed widgets. I am also looking for fade animation based on opaque levels for a pixmap based image (currenty QLabel, which
has no alpha modification property, but I believe QGraphicsWidget does).

How would one revise my current QStackWidget based framework to support the animation requirements?


QUESTIONS #2: QGraphicsView/OpenGL benefits/embedded performance
------------

I am NOT currently not using QGraphicsView or graphics based class derivatives. The components that are currently being used include QListWidget,

QStackedWidgets, QLabel, QFrame, and other basic components available within QtCreator. The animation requirements that we currently have are for
screen transitions as described, and perhaps 2D graphing.

I am pondering the benefits of using QGraphicsView and OpenGL for the user interface, and what that might mean to embedded performance.
It is not yet know whether the target Atom board will provide hardware graphics acceleration (GPU), and how that might influence the decision on the Qt

application base classes and implementation.

I would welcome you input on this question, i.e. create a UI without using QGraphicsView/OpenGL or not from the perspective of application performance.

I welcome any general direction.

[vladest]

Just use QAnimationProperty
Actually, Qt animation can be used with any class, derived from QObject by setting appropriate property