polling betrieb?



  • Hallo zusammen,

    ich habe mal wieder eine Frage. Ich habe eine TCheckBox. Wenn ich die abhake, soll eine int var inkrementiert werden und im Memofenster angezeigt werden. Wenn ich, wärend des inkrementieren der var, nun erneut die TCheckBos abhake, soll das Inkrementieren stoppen.

    Habe hier mal zwei Funktionen geschrieben.

    void __fastcall TForm1::CheckBox1Click(TObject *Sender)
    {
    int dMessOLD = 0;
    
    dMessOLD = dMess;
    dMess    = 1;
    
    if(dMessOLD)
     dMess=0;
    }
    
    void Counter(TMemo *Memo1){
    
    double reg = 0;
    AnsiString Ausgabe;
    
    while(dMess){
        reg++;
        Ausgabe += reg;
        Memo1->Clear();
        Memo1->Lines->Add(Ausgabe);
        };
    }
    

    Ich erkenne das Problem selbst. Wenn die TCheckBox abgehakt ist und Counter aufgerufen wird, geht die GUI in die while-schleife und verabschiedet sich. Ich müsste in so eine Art polling modus gehen. Aber wie mache ich das? Der Inhalt der while-schleife in Counter kann auch ein beliebiger sein, d.h. ich möchte nut weil die fkt counter heißt, keine couter-funktion programmieren.

    Welche Klassen kommern für das Problem in Frage?

    lg,
    blitzgeist



  • Ja das kommt nun drauf an, was genau Du machen willst.

    Wenn Du im Prinzip eine Schleife hast, die permanent (mit hoher Priorität) laufen soll, kannst Du irgendwo in der Schleife ein Application->ProcessMessages() einbauen. Dies sorgt dafür, dass die Nachrichtenwarteschlange des Programms weiter abgearbeitet wird und das Programm bleibt weiterhin bedienbar. Je nachdem aber nur sehr schleppend...

    Alternativ kann ein TTimer verwendet werden, der dann z.B. jede Sekunde einmal die Funktion ausführt.

    Für einen Counter wäre die Timer-Lösung die bessere, aber die willst du ja eigentlich nicht.



  • Hallo,

    ich würde einfach noch ein boolean übergeben...

    void __fastcall TForm1::CheckBox1Click(TObject *Sender)
    {
    if (CheckBox1->Checked)
            Counter(Memo1, true);
    else
            Counter(Memo1, false);
    }
    //---------------------------------------------------------------------------
    void __fastcall TForm1::Counter(TMemo *Memo1, bool active)
    {
    if (active)
    {
        //machwas();
        //Application->ProcessMessages() nicht vergessen...
    }
    }
    

    mfg, Micha



  • Hi RandomAccess85,

    über Application->ProcessMessages() wird somit gewährleistet, dass ich noch meine GUI bedienen kann und jetzt deine eingeführte bool var active wieder auf false setzten kann. Aber was ist mit der Aussage von Joe_M

    ProcessMessages() einbauen. Dies sorgt dafür, dass die Nachrichtenwarteschlange des Programms weiter abgearbeitet wird und das Programm bleibt weiterhin bedienbar. Je nachdem aber nur sehr schleppend...

    Geht das mittels eines Timers schneller, besser? Am besten mal beide Varianten ausprobieren...
    Oder wie seht ihr das?

    lg,
    blitzgeist



  • Hallo,

    ja ich würd auch sagen, dass du an deine Routine angepasst einfach mal beide Varianten untersuchst und dann für dich entscheidest was schneller geht bzw. die bessere Performance liefert 😉

    mfg, Micha!



  • Nun ja, es gäbe ja auch noch die Möglichkeit, das in einen eigenen Thread auszulagern...
    Es ist aber nicht möglich, Dir einen Weg zu empfehlen, so lange wir nicht wissen, was genau da passieren soll.



  • also habe das jetzt so

    void __fastcall TForm1::CheckBox1Click(TObject *Sender)
    {
    if(CheckBox1->Checked){
        dMess = 1;
        Counter(Memo1, dMess);
        }
    else{
        dMess = 0;
        Counter(Memo1, dMess);
        }
    }
    
    double reg = 0;
    void Counter(TMemo *Memo1, int dMess){
    
    AnsiString Ausgabe;
    
    while(dMess){
        reg++;
        Ausgabe += reg;
        Memo1->Clear();
        Memo1->Lines->Add(Ausgabe);
        Application->ProcessMessages();
        };
    }
    

    Sobald ich die CheckBox abhake, läft die ganze Sache los, kann auch meine GUI "bedienen", d.h. ich hacke die CheckBox wieder ab, Häkchen verschwindet, aber im Memofenster rasseln als noch die Zahlen herunter. Ich dachte jetzt nach dem Abhaken würde auch das Zählen aufhören, weil die while schleife false ist. Dem ist aber nicht so. Wieso?



  • Das liegt daran, dass Du in der Funktion Counter eine lokale Kopie der globalen Variable dMess übergibst. Diese lokale Kopie wird niemals 0, also stoppt die Schleife auch nie.



  • ...also pointer



  • Hä? Nö.



  • Dachte über nen pointer aud dMess könnte ich es lösen. Wieso nicht?



  • ich habs nun... 🙂



  • Du hast eine globale Variable dMess. Aber in der Funktion Counter verwendest Du eine nur in dieser Funktion bekannte Variable gleichen Namens. Lass das dMess einfach komplett aus den Funktionsparametern raus. Und wenn Du Counter zu einer Memberfunktion von TForm1 machst, brauchst Du auch das Memo nicht zu übergeben.
    Und wenn Du dann noch alle globalen Variablen zu privaten Membervariablen des Forms machst, kommt langsam Land in Sicht... 😉



  • Hallo Joe_M,

    danke für deine Tipps. Eigendlich habe ich schon meine Funktion wie ich so gerne haben möchte mit ProcessMessages(). Nur eines verstehe ich noch nicht. Im Memofenster läuft schön meine Variable hoch und wenn ich die CheckBox wieder abhake bleibt sie stehen. Wärend des zählens kann ich auch alle anderen Funktionen bediene, nur nicht mein Butto beenden der die Funktion Close(); aufruft. Jedoch klicke ich auf den Button beenden wärend des Zählens und ich dann die CheckBox wieder abhake (also Haken weg), dann erst wird der Button beenden bedient und die GUI schließt sich.
    Die Priorität der Funktion Close() scheint sehr niedrig zu sein. Wie kann ich das ändern, dass mein Button beenden auch wärend des Zählens bedient wird und die GUI sich schließ?



  • Hallo

    Genau deshalb wurde dir zu TTimer/TThread geraten.

    bis bald
    akari


Log in to reply