I stumbled across this thread and it got me thinking:
LC has cards, which are great for many things but somewhat limited.
For example, as the OP asks about there: how does one swipe between them?
That seems a perfectly reasonable expectation, given what cards are and
the central role they play in LC's object model and language.
And yet we don't really have any way of doing that.
Doing it right on mobile would mean some drag-triggered transition which
responds to the drag movement itself, and could be canceled if the user
releases their finger before a certain mid-screen threshold is reached.
Of course we can do that with groups, but consider what that means:
We'd have to construct all of our layouts on a single card, and have
some means of moving the groups on and off screen as needed, both during
development and at runtime.
All doable, and not too much of a brain-bender.
But it's work. And non-obvious to newcomers. And even for experienced
devs it's tedious.
And at that point, the beautiful simplicity of the card metaphor breaks
down. Indeed, it's no longer even relevant because we're not using
cards at all, but groups on a single card.
At that point, some of the advantage of choosing LiveCode is lost,
because one of the most central elements of its object model is no
longer a best fit for today's designs.
Modern UIs (most mobile and increasingly on desktop as well) benefit
from providing a sense of unifying flow with, among other things,
interactive drag actions as transitions between screen layouts.
I was considering putting in a feature request for a new drag
transition, but before I do I think we need some design work to figure
out exactly what it should do and how we work with it.
It's not even a transition per se, since those are discrete visual
operations performed after a user action has been completed (e.g., a
mouses click or a menu selection).
This seems perhaps a good candidate for a property, maybe something like
"the dragTransitions" of a stack. When true, any drag actions not
handled by any script would be handled by the engine by dragging a
transition from card to card according to the direction of the drag.
That may be too simplistic, though. Do we really want free travel
between all cards in a stack? If not, how do we specify what happens in
response to a drag when we want a card-to-card transition?
Fourth World Systems
Software Design and Development for the Desktop, Mobile, and the Web
use-livecode mailing list
Please visit this url to subscribe, unsubscribe and manage your subscription