Herzlich Willkommen, lieber Gast!
  Sie befinden sich hier:

  Forum » C / C++ (ANSI-Standard) » Touchscreen Move Event

Forum | Hilfe | Team | Links | Impressum | > Suche < | Mitglieder | Registrieren | Einloggen
  Quicklinks: MSDN-Online || STL || clib Reference Grundlagen || Literatur || E-Books || Zubehör || > F.A.Q. < || Downloads   

Autor Thread - Seiten: > 1 < [ 2 ] [ 3 ]
000
08.03.2017, 13:58 Uhr
Satcamel



Hallo, bin noch neu in der Materie aber willig tzu lernen.
Meine anliegen ist das ich einen Slide event brauche bzw erkennen will in welche richtung über den Touchsreen gefahren wird.
In der API gibt es die events Tap, Release und Move sowie Longpress.
Kann mir jemand hilfeleistung geben wie ich das löse?
Benutze die Eclipse ide und das "Rephone" (Xadow GSM/BLE) Modul.
Bin für jede hilfe dankbar

MFG Dirk
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
001
09.03.2017, 12:44 Uhr
ao

(Operator)


Wenn ich die Frage mit den gegebenen Informationen beantworten könnte, wäre ich Hellseher und müsste mein Leben nicht als Programmierer fristen. Immerhin weiß ich inzwischen, was ein Rephone-Modul ist, nur über die API-Doku bin ich noch nicht gestolpert und habe auch keine Lust, mir selber die Finger wund zu googeln. Wenn du also freundlicherweise einen Link posten würdest, unter dem man das nachlesen kann? Danke.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
002
09.03.2017, 15:20 Uhr
Satcamel



Hi , sorry für meine Unwissenheit und unklare Frage :-)
Hier der Link zur API, es handelt sich bei dem Chip um den Mediatek Assist 2502.

http://labs.mediatek.com/api/linkit-assist-2502/frames.html?frmname=topic&frmfile=index.html
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
003
09.03.2017, 15:27 Uhr
Satcamel



Anbei der Inhalt des vmtouch.h
Hoffe das hilft weiter ;-)

C++:
//////////////////////////////////////////////////////////////////////////////////////
#ifndef VMTOUCH_SDK_H
#define VMTOUCH_SDK_H

#ifdef __cplusplus
extern "C" {
#endif

#include "vmtype.h"

typedef enum
{
    VM_TOUCH_EVENT_TAP = 1,         /* Touch down event. */
    VM_TOUCH_EVENT_RELEASE = 2,     /* Touch release event. */
    VM_TOUCH_EVENT_MOVE = 3,        /* Touch move event. */
    VM_TOUCH_EVENT_LONG_TAP = 4,    /* Touch long tap event. Note:
                                       1. VM_TOUCH_EVENT_LONG_TAP event is
                                          invoked when the Touch is tapped for
                                          a period of time and stays at the
                                          same place where it is tapped down.
                                       2. If Touch move happen after Touch down,
                                          there will be no
                                          VM_TOUCH_EVENT_LONG_TAP event.
                                       3. VM_TOUCH_EVENT_LONG_TAP can only
                                          happen one time at most before
                                          VM_TOUCH_EVENT_RELEASE. */

    VM_TOUCH_EVENT_DOUBLE_CLICK = 5,/* Touch double click event. */
    VM_TOUCH_EVENT_REPEAT = 6,      /* Touch repeat event. Note:
                                       1. VM_TOUCH_EVENT_REPEAT can happen after
                                          VM_TOUCH_EVENT_LONG_TAP or
                                          VM_TOUCH_EVENT_MOVE or another
                                          VM_TOUCH_EVENT_REPEAT.
                                       2. The coordinate follows
                                          previous VM_TOUCH_EVENT_REPEAT
                                          events.*/

    VM_TOUCH_EVENT_ABORT = 7,       /* Touch abort event. */

    VM_TOUCH_EVENT_MAX = 0x7FFFFFFF
} VM_TOUCH_EVENT;

/*****************************************************************************
* FUNCTION
*  vm_touch_event_callback
* DESCRIPTION
*  Callback of touch events.
* PARAMETERS
*  event: [IN] touch event,see VM_TOUCH_EVENT
*  x: [IN] x coordinate, starting from upper-left of the display, in pixels.
*  y: [IN] y coordinate, starting from upper-left of the display, in pixels.
* RETURNS
*  void
*****************************************************************************/

typedef void (*vm_touch_event_callback)(VM_TOUCH_EVENT event, VMINT x, VMINT y);

/*****************************************************************************
* FUNCTION
*  vm_touch_register_event_callback
* DESCRIPTION
*  Registers touch event callback.
* PARAMETERS
*  callback : [IN] touch event callback.
* RETURNS
*  VM_RESULT
*****************************************************************************/

VM_RESULT vm_touch_register_event_callback(vm_touch_event_callback callback);

#ifdef __cplusplus
}
#endif

#endif /* VMTOUCH_SDK_H */


-----
Edit: cpp-Tags + oberste Kommentarzeile eingesetzt.

Dieser Post wurde am 09.03.2017 um 15:58 Uhr von Hans editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
004
09.03.2017, 17:32 Uhr
ao

(Operator)


Ok, also, ich schätze, man muss eine Funktion schreiben, die so aussieht:

C++:
void my_touch_event_handler (VM_TOUCH_EVENT event, VMINT x, VMINT y)
{
}



In dieser Funktion macht man alles, was getan werden muss, wenn ein Touch-Event auftritt, etwa so:

C++:
switch (event)
{
case VM_TOUCH_EVENT_TAP:
    //    Tap-Event (Finger runter) behandeln
    break;

case VM_TOUCH_EVENT_RELEASE:
    //    Release-Event (Finger hoch) behandeln
    break;

case VM_TOUCH_EVENT_MOVE:
    //    Move-Event (Finger bewegt sich) behandeln
    break;

//    und so weiter
}


Abhängig davon, welcher Event aufgetreten ist (Tap, Release, Move, ...), muss man die entsprechende Reaktion programmieren. Die Parameter x und y bedeuten immer die absolute Position auf dem Display, an welcher der Event aufgetreten ist.

Am besten erst mal in jedes Case eine Debug-Ausgabe einprogrammieren (z.B. "Tap x=soundso, y=soundso"), so kriegst du ein Gefühl dafür, welche Gesten welche Events erzeugen. Bei den "trivialen" Events (Tap, Release) ist das mehr oder weniger klar, aber bei Move z.B. ist interessant, in welchen Abständen (zeitlich oder räumlich) die Events gefeuert werden, weil das die Auflösung definiert, mit der Bewegungen erfasst werden können. Und das Verhalten von Longtap und Repeat muss man vermutlich auch erst mal erforschen.

Dann muss man den Touch-Event-Handler noch im System anmelden, damit er bei Bedarf vom System aufgerufen werden kann:

C++:
VM_RESULT result = vm_touch_register_event_callback (my_touch_event_handler);
if (VM_IS_FAILED (result)) exit (EXIT_FAILED);


Das macht man normalerweise während des Starts der Applikation.

Dieser Post wurde am 09.03.2017 um 17:42 Uhr von ao editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
005
09.03.2017, 19:02 Uhr
Satcamel



ok, danke.
Es gibt eine testroutine. Diese gibt einem den Touch Event und die Koordinaten an (X,Y).
Wenn ich über den ganzen Bildschirm fahre mit dem Finger dann beckomme ich Event 3 (Move )
Angezeigt und die Koordinaten solange ich fahre.
Aber das alleine hilft mir ja nocht wirklich direkt weiter. Ich muß ja irgendwie herausfinden ob ich nach rechts oder links "fahre" oder von oben nach unten.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
006
09.03.2017, 20:01 Uhr
ao

(Operator)


Das müsste eigentlich an den X-Y-Koordinaten zu erkennen sein, die mit den Move-Events kommen.

Nach der Beschreibung liefert jeder Event den Ort mit, an dem er entstanden ist. Die Bewegungsrichtung ergibt sich aus der Differenz zweier aufeinanderfolgender Orte.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
007
09.03.2017, 20:14 Uhr
Satcamel



Das ist das Problem, ich sehe nicht den Startwert von X sondern nur den Endwert
Dieser Post wurde am 09.03.2017 um 21:00 Uhr von Satcamel editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
008
09.03.2017, 21:27 Uhr
FloSoft
Medialer Over-Flow
(Administrator)


wenn du bei einem move immer

tap, move, ... , release

an events bekommst, kannst du die bewegungsrichtugn ja ermitteln. du weiß ja dann, wo der finger "runterkam" bzw wann er aufhört sich zu bewegen ("release")
--
class God : public ChuckNorris { };
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
009
09.03.2017, 22:36 Uhr
Hans
Library Walker
(Operator)



Zitat von Satcamel:
Das ist das Problem, ich sehe nicht den Startwert von X sondern nur den Endwert

Du musst in Deinem Programm Variablen anlegen, in denen Du Dir die Koordoinaten merkst, die die Funktion liefert. Und wenn Du die Funktion noch einmal aufrufst, vergleichst Du die aktuell gelieferen Werte mit denen, die Du zuvor gespeichert hast. Aus den Unterschieden kannst Du dann auf die Bewegungsrichtung schliessen.
Der Punkt ist also: Du musst die Funktionen in regelmässigen Abständen immer wieder aufrufen und die gelieferten Ergebnisse mit denen aus früheren Aufrufen vergleichen. Ein einmaliger Aufruf allein hilft da nicht weiter.

Wird denn von der Testroutine, von der Du in Posting #005 schreibst, auch der Quellcode mitgeliefert? - Wenn ja, dann solltest Du Dir den ansehen, und versuchen zu verstehen, was da gemacht wird. Wenn Du dabei nicht durch alles durchblickst ist das nicht tragisch. Dann versuche herauszufinden, welche Teile für Dich relevant sind, und diese zu verstehen.
--
Man muss nicht alles wissen, aber man sollte wissen, wo es steht. Zum Beispiel hier: Nachdenkseiten oder Infoportal Globalisierung.

Dieser Post wurde am 09.03.2017 um 22:38 Uhr von Hans editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
Seiten: > 1 < [ 2 ] [ 3 ]     [ C / C++ (ANSI-Standard) ]  


ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: