3. GetAsyncKeyState problem

GetAsyncKeyState problem

  • C

    guten tag liebe community
    ich wollte fragen ob es möglch ist eine void funktion di in einer for schleufe aufgefufen wird
    durch einen tasten druck, zb. o dauerhaft zu aktiviern, so dasser des immer macht ?(mir fällt grad net des richtige word ein :))

    also ich hab dise code:

    void bla ()
{
    if(GetAsyncKeyState('O'))
{
die funktion
}
}

    so ruf ich sie auf :
    [cpp]void aufrufen()
    {
    for(;; )
    {
    Bla();
    ...();
    Sleep(30);
    }
    }

    so jetzt noch mal die frage deutlicher :
    ist es möglich, das wenn ich die taste o drücke, das er des dann so lange macht bis er ne ander taste gedrückt bekommt, z.B. ö also

    ich hoffe ich war deutlich 😃

    0

  • cracy112 schrieb:

    ich hoffe ich war deutlich 😃

    Die Hoffnung stribt zuletzt 😉

    Also nein, warst du nicht.

    0
  • _

    Sieh dir mal an, wie Threads funktionieren. Wenn die Taste gedrückt wird, startest du einen Thread, der deine Funktion in einer Schleife ausführt, und bei einem anderen Tastendruck beendest du ihn wieder (oder hältst ihn an).

    0
  • C

    also ok ich bersuchs nochmal deútlicher 🙂
    also dieses void bla oder was ich da genommen habe
    des wird ja immer wieder von dem anderen void aifgefufen durch die schleife
    so wenn man nichts drückt, dann passiert in dem void bla nichts ...
    wenn man aber ine bestimmte taste drückt, z.B. o soll er das Void was in der schleife ausgeführt wird immer ausführen, biss man eine gewisse taste drückt also so

    bla wird von der schleife aufgerufen
    ---|---
    die taste wurde nicht gedrückt die er bei GetAsyncKeyState hätte bekommen müssen
    ---|---
    bla wird von der schleife aufgerufen
    ---|---
    die taste wurde gedrückt also führt es jetzt das eine aus was ich unter GetAsyncKeyState gersetzt habe also des hier

    if(GetAsyncKeyState('O'))
{
die funktion //  <------

    ---|---
    bla wird von der schleife aufgerufen
    ---|---
    taste wiud nicght mehr gedrückt, er führt aber trotzdem die fuktion aus weil sie beim vorhärigen mahle gedrückt worden war
    ---|---
    bla wird von der schleife aufgerufen
    ---|---
    eine andere taste wurde gesdrückt sagen wir die btaste P
    ---|---
    jetzt wird des in Bla nicht mehr ausgeführt, weil die taste p gesrückt wurde

    ... usw

    dass sollte aber deutlich sein oder 😉

    0
  • K

    🙄
    Ich hätte dir eher zu einem schönen Callback-System mit Boost.Function, Boost.Bind und Boost.Thread geraten. Aber in meinen Augen bist du noch Anfänger, also lerne noch mal die Grundlagen und lies dir http://www.tty1.net/smart-questions_de.html durch.

    0

  • @cracy112:
    Deutlich ist was anderes, aber jetzt kann man wenigstens mal raten.

    Du brauchst eine Variable (global, oder besser als Member einer Klasse) in der du abspeicherst welche Taste zuletzt gedrückt war. Oder welche Funktion beim nächsten Aufruf von bla() ausgeführt werden soll.

    int whatToDo = 0;

void bla()
{
    if (GetAsynkKeyState(...)...)
        whatToDo = 1;
    else if (GetAsynkKeyState(...)...)
        whatToDo = 2;

    if (whatToDo == 1)
        do1();
    else if (whatToDo == 2)
        do2();
    else
        doElse();
}

    Natürlich kann man statt der Variable auch Funktionszeiger oder tr1::function nehmen, aber das ist denke ich mal die einfachste Lösung.

    0
  • C

    hab jetzt anders selbt hinbekommen ^^

    if(bla==true)

    das hab ch darein gesetzt
    und so ruf ichs auf:

    if (GetAsyncKeyState('M')&1)
{
bla = bla==false;
}
    0
  • U
     

    bla = bla==false;

    -> bla = !bla; ;o)

    if (GetAsyncKeyState('M')&1)

    würd ich im übrigen in ne extra Funktion packen - ich mag API-Fkt eh nie direkt im Code nutzen - falls man irgendwann doch mal denkt, dass man das ganze evtl auch mal auf ne andere plattform portieren könnte, sucht man dann ewig, wo überall man die api-fkt aufruft...

    /*../windows/key_codes.h*/
#define NOMINMAX
/*noch mehr böse winapi-makros durch schalter deaktiveren*/
#include "windows.h"
#undef NOMINMAX
#undef IN
#undef OUT
/*noch mehr böse winapi-makros deaktiveren, für die es keine schalter gibt*/

enum key_codes
{
  A = 'A', /*...*/
  NUM_PAD_0 = ...,
...
};

namespace detail
{
  bool key_pressed(key_codes key)
  {
    return 0x01&GetAsyncKeyState(int(key));
  }
  bool key_pressed_since_last_call(key_codes key)
  {
    return 0x02&GetAsyncKeyState(int(key));
  }
}

    /*../posix/key_codes.h*/
enum key_codes
{
  /*...*/
};

/*...*/

    #if defined(_WIN32) || defined(_WIN64)
#  include "windows/key_codes.h"
#elif defined(kein_plan_worauf_man_hier_testet)
#  include "posix/key_codes.h"
#else
#  error not supported platform
#endif

bool key_pressed(key_codes key)
{
  return detail::key_pressed(key);
}
bool key_pressed_since_last_call(key_codes key)
{
  return detail::key_pressed_since_last_call(key);
}

    so in etwa sollte es funktionieren - und die paar zeilen mehr sollten nicht weiter schlimm sein - ok, die enums werden ein wenig schreibarbeit sein - aber ansonsten sollte es sich vom aufwand her nichts nehmen.

    bb

    PS: Windows Key-Codes gibts hier:
    http://msdn.microsoft.com/en-us/library/dd375731%28v=VS.85%29.aspx

    0
Anmelden zum Antworten