Schleifen-Problem

WebFritzi

Original erstellt von <*LUSTIG*>:
witzig zu sein? das war einfach nur die wahrheit. traurig aber wahr.

Ich finds einfach nur lustig, du kleines dummes A-r-s-c-h-l-o-c-h !!!

WebFritzi

Schön, dass du dich für meine Hilfe bedankst, Julx5 !

Schön, dass du dich für meinen Kommentar beleidigst, W-E-B-F-R-I-T-Z-I ! :o

ups :p

Julx5

*while(bDoLoop && ProcessMessages())

if(wparam == VK_F12)
{
bDoLoop = TRUE;

while(bDoLoop && ProcessMessages())
xxxDDraw_Puffer_wechseln();

PostMessage(hwnd, WM_CLOSE, 0,0);
}*

ich glaub da hast du was mit ProcessMessages() falsch gemacht, den befehl kennt er nicht (msdn hab ich auch nichts gefunden)

das ist nur psycho code. ProcessMessages ist glaub ich von der VCL (Borland C++ Builder)

WebFritzi

Man Julx!!! Das kann doch wirklich nicht sein! ProcessMessages() ist die Funktion, die du über die Suchfunktion findest, und an der du dich angeblich auch schon versucht hast.

Julx5

jaja ist schon gut, hab allerdings schon ne lösung zusammen mit flenders gefunden, etwa im prinzip genau wie die von webfritzchen (halt ohne dein unbekanntes ProcessMessages;-)

also allen nochmal vie dank!

So geht's, wenn die Nachrichten abgeholt werden:

enum { WMU_DOTHELOOP = WM_USER + 789 };

LRESULT CALLBACK WindowProc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
{
   static BOOL sbLoopAnhalten = FALSE;
   switch(message)
   {
   case WM_DESTROY/*und andere*/:
      //...
      break;
   case WM_KEYDOWN:
      switch(wparam)
      {
      case VK_ESCAPE:
      case VK_RETURN:
         sbLoopAnhalten = TRUE;
         PostMessage(hwnd, WM_CLOSE, 0, 0);
         return 0;
      case VK_F12:
         sbLoopAnhalten = FALSE;
         PostMessage(hwnd, WMU_DOTHELOOP, 0, 0);
         return 0;
        }//ende sitch(wparam) 
      break; //ende case wm_keydown
   case WMU_DOTHELOOP:
      if(!sbLoopAnhalten)
      {
         xxxDDraw_Puffer_wechseln();
         PostMessage(hwnd, WMU_DOTHELOOP, 0, 0);
      }
      return 0;
   }//ende switch(msg)
   return DefWindowProc(hwnd, message, wparam, lparam);
} //Ende der WindowProc

Julx5

ja, so ist es auch ganz leicht, jedoch sollte xxx_bufferwechseln() inner endlosschleife stattfinden und von dort sollten die nachrichten abgeholt werden.

So geht's, wenn die Nachrichten abgeholt werden:

enum { WMU_DOTHELOOP = WM_USER + 789 };

LRESULT CALLBACK WindowProc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
{
    static BOOL sbLoopAnhalten = FALSE;
    switch(message)
    {
    case WM_DESTROY/*und andere*/:
        //...
        break;
    case WM_KEYDOWN:
        switch(wparam)
        {
        case VK_ESCAPE:
        case VK_RETURN:
            sbLoopAnhalten = TRUE;
            PostMessage(hwnd, WM_CLOSE, 0, 0);
            return 0;
        case VK_F12:
            sbLoopAnhalten = FALSE;
            PostMessage(hwnd, WMU_DOTHELOOP, 0, 0);
            return 0;
        }//ende sitch(wparam) 
        break; //ende case wm_keydown
    case WMU_DOTHELOOP:
        if(!sbLoopAnhalten)
        {
            xxxDDraw_Puffer_wechseln();
            PostMessage(hwnd, WMU_DOTHELOOP, 0, 0);
        }
        return 0;
    }//ende switch(msg)
    return DefWindowProc(hwnd, message, wparam, lparam);
} //Ende der WindowProc

Du läßt durch PostMessage(..., WMU_DOTHELOOP, ...) sowohl die Endlosschleife als auch die Nachrichtenabholung von Windows machen!
Hoffe, das hilft?!?!

WebFritzi

Ich denke, das ist kein guter Ansatz, denn so ist die "Endlos"-Schleife von der Message-Queue abhängig, und die kann u.U. recht langsam sein. Um sich ganz von der Message-Queue abzuseilen, könnte ein neuer Thread auch eine gute Möglichkeit sein.

Julx5

stimmt, manchmal frage mich warum ich das nicht am anfang angwendet habe
MULTITHREADING

na egal hauptsache es funzt!

Krösus

WebFritzi:
Der Ansatz hat vielleicht Vor- und Nachteile. Deshalb kannst Du aber noch lange nicht behaupten, er sei nicht gut.
Es kann sein, daß mit Multithreading mit Kanonen auf Spatzen geschossen wird - oder aber daß Multithreading das Mittel der Wahl ist. Das muß aber der Programmierer (nicht Du!) entscheiden, der ja seine Message-Loop kennt.

Hier mein Lösungsvorschlag für Multithreading:

//Variable zur Thread-Steuerung
static BOOL sbLoopAnhalten = FALSE;

static DWORD WINAPI WorkerThread(LPVOID unused)
{
    while(!sbLoopAnhalten)
        xxxDDraw_Puffer_wechseln();
    return 0;
}

LRESULT CALLBACK WindowProc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
{
    static BOOL sbLoopAnhalten = FALSE;
    switch(message)
    {
    case WM_DESTROY/*und andere*/:
        //...
        break;
    case WM_KEYDOWN:
        switch(wparam)
        {
        case VK_ESCAPE:
        case VK_RETURN:
            sbLoopAnhalten = TRUE;
            PostMessage(hwnd, WM_CLOSE, 0, 0);
            return 0;
        case VK_F12:
            sbLoopAnhalten = FALSE;
            {
                //CreateThread
                DWORD iThreadID;
                CreateThread(NULL, 0, &WorkerThread, NULL, 0, &iThreadID);
            }
            return 0;
        }//ende sitch(wparam) 
        break; //ende case wm_keydown
    }//ende switch(msg)
    return DefWindowProc(hwnd, message, wparam, lparam);
} //Ende der WindowProc

WebFritzi

Original erstellt von Krösus:
WebFritzi:
Der Ansatz hat vielleicht Vor- und Nachteile. Deshalb kannst Du aber noch lange nicht behaupten, er sei nicht gut.
Es kann sein, daß mit Multithreading mit Kanonen auf Spatzen geschossen wird - oder aber daß Multithreading das Mittel der Wahl ist.

Hmm, du hast recht. Eigentlich meinte ich, dass deine Lösung nicht so gut ist wie meine. Aber auch da lag ich falsch, denn wenn man mal etwas gründlicher überlegt, kommt man zum SChluss, dass genau das Gleiche dabei herumkommt. Im Gegenteil - deine Methode ist um Längen eleganter: ohne BOOL-Variable und ohne Extra-Funktion für ne neue Message-Loop, die einen nur verwirrt. Super!