dynamische Label



  • Einfach nen Timer nehmen ...



  • Nein kein Sleep, sondern ein Application->ProcessMessages().
    Dadurch werden die Botschaften der Anwendungen verarbeitet, die unter anderem auch für das Aktualisieren der grafischen Oberfläche verantwortlich sind. Ein Sleep hält die Anwedung nur an, eine Botschaftenverarbeitung findet deswegen aber nicht statt.



  • Einfach deine Messages in einer TStringList speichern und diese dann im OnTimer Event nacheinander anzeigen lassen.



  • timerfreund schrieb:

    Einfach nen Timer nehmen ...

    Ja, man kann auch eine Three-Tier Datenbankanwendung schreiben, um ein einziges Textdokument zu verwalten...



  • Joe_M. schrieb:

    timerfreund schrieb:

    Einfach nen Timer nehmen ...

    Ja, man kann auch eine Three-Tier Datenbankanwendung schreiben, um ein einziges Textdokument zu verwalten...

    Also ich würde meine Anwendung niemals blockieren nur um etwas auszugeben oder zu speichern ...
    🙄



  • hmm nacheinander anzeigen lassen geht nicht so einfach,
    weil nicht immer alle Nachrichten angezeigt werden,
    bzw auch in den verschiedensten Reihenfolgen.

    ich bräuchte was das ich direkt nach der Ausgabe coden könnte,
    also nen Befehl nachm der Ausgabe.

    wie genau funzt des mit ProcessMessages....



  • Sollten die Werte einfach tatsächlichnur zu schnell erzeugt werden, um diese noch lesen zu können, ist ein Label nicht geeignet. Dann würde ich eher auf ein Memo oder eine ListBox ausweichen. Dort kannst Du dann mehrere Werte nacheinander darstellen.

    Wenn Du an ein einziges Label gebunden bist, könntest Du ein Application->ProcessMessages() ausführen und direkt danach ein Sleep einbauen. Aber ich persönlich halte nichts davon, Anwendungen künstlich auszubremsen, nur um dem User die Daten in einer lesbaren Geschwindigkeit anzuzeigen.

    Schau doch mal in der Hilfe zu TApplication::ProcessMessages().



  • Aber ich persönlich halte nichts davon, Anwendungen künstlich auszubremsen, nur um dem User die Daten in einer lesbaren Geschwindigkeit anzuzeigen.

    Mein reden ...



  • naja ne Listbox oder ne Memo gehen auch net wirklich,
    ich habe da net den Platz dafür und
    ich kann die Messages da nicht haufen weise speichern lassen.

    sollte einfach hintereinandern angezeigt werden:
    Bsp: Update -> Update successfull -> Synchroniziation -> Data found -> Ready



  • Ok, wie schnell trudeln die Messages denn ein? Ist das permanent der Fall, oder gibt es zwischendurch 'Ruhezeiten'? Wie wichtig ist die Aktualität der Anzeige?

    Wenn es zwischendurch Ruhezeiten gibt und es nicht so wichtig ist, dass aktuelle Nachrichten zeitnah ausgegeben werden, könntest Du die Nachrichten z.B. in einer TStringList zwischenspeichern und von dort tatsächlich Timer-gesteuert ausgeben.



  • budili schrieb:

    naja ne Listbox oder ne Memo gehen auch net wirklich,
    ich habe da net den Platz dafür und
    ich kann die Messages da nicht haufen weise speichern lassen.

    Man könnte das auch so gestalten, dass immer nur die 3 letzten Nachrichten in der ListBox stehen.



  • nee mit der Listbox würde das net gehn,
    habe echt nur eine Zeile zur Verfügung.

    die Aktualität ist der Nachrichten hat ne hohe Priorität !
    ich kann nicht die Nachrichten anzeigen von den letzten paar Minuten.

    wär es den mit dem sleep oder net am einfachsten,
    das ich praktisch für ne Sekunde oder so kurz anzeigen lasse ??



  • Doch kannst Du, allerdings verzichte ich dann líeber auf die Anzeige einer Nachricht, als die Anwendung künstlich auszubremsen. Schreib die Nachrichten doch zusätzlich in ein LogFile. Wenn dann jemand alle Nachrichten sehen will, kann er sich das ja ansehen.



  • jo das mit Log File is scho drin,
    bzw es sind mehrere.

    naja gut, dann lasse ich das erstmal so,
    das nur die wichtigsten angezeigt werden. 😞



  • irgendwie versteh ich das noch nicht ganz!

    du benutzt doch sicher funktionen, dann lass doch zB in der synchronize() das Label ändern usw...

    und sowieso, wenn die nachrichten sooooooo schnell kommen, kann die ja eh keiner lesen....

    achso, und ein memo kannst du auch so klaein machen wie du willst, hat dann eben scrollbars, oder man kann mit der tastatur "scrollen"



  • ja so hab ichs ja, ich setze die Labels in den Funktionen.

    nur ist es für den Anwender nicht mehr wichtig was vor 20 sec
    geschehen ist. deshalb ist die Akualität ja relativ wichtig.

    das Ding soll nur kurz anzeigen, was er grad tut,
    mehr isses nicht...



  • Mach es doch einfach mit einem Timer. Stell den Intervall auf den Wert, den du brauchst, und gut ist.

    Unit1.h

    //---------------------------------------------------------------------------
    
    #ifndef Unit1H
    #define Unit1H
    //---------------------------------------------------------------------------
    #include <Classes.hpp>
    #include <Controls.hpp>
    #include <StdCtrls.hpp>
    #include <Forms.hpp>
    #include <ExtCtrls.hpp>
    //---------------------------------------------------------------------------
    class TForm1 : public TForm
    {
    __published:	// Von der IDE verwaltete Komponenten
       TTimer *Timer1;
       TButton *Button1;
       TButton *Button2;
       TButton *Button3;
       TLabel *Label1;
       void __fastcall Button1Click(TObject *Sender);
       void __fastcall Button2Click(TObject *Sender);
       void __fastcall Button3Click(TObject *Sender);
       void __fastcall Timer1Timer(TObject *Sender);
    private:	// Anwender-Deklarationen
    String message;
    public:		// Anwender-Deklarationen
       __fastcall TForm1(TComponent* Owner);
    };
    //---------------------------------------------------------------------------
    extern PACKAGE TForm1 *Form1;
    //---------------------------------------------------------------------------
    #endif
    

    Unit1.cpp

    //---------------------------------------------------------------------------
    
    #include <vcl.h>
    #pragma hdrstop
    
    #include "Unit1.h"
    //---------------------------------------------------------------------------
    #pragma package(smart_init)
    #pragma resource "*.dfm"
    TForm1 *Form1;
    //---------------------------------------------------------------------------
    __fastcall TForm1::TForm1(TComponent* Owner)
       : TForm(Owner)
    {
    
    }
    //---------------------------------------------------------------------------
    
    void __fastcall TForm1::Button1Click(TObject *Sender)
    {
       message="tue dies";
    }
    //---------------------------------------------------------------------------
    void __fastcall TForm1::Button2Click(TObject *Sender)
    {
       message="tue das";
    }
    //---------------------------------------------------------------------------
    void __fastcall TForm1::Button3Click(TObject *Sender)
    {
       message="tue nochirgendwas";
    }
    //---------------------------------------------------------------------------
    void __fastcall TForm1::Timer1Timer(TObject *Sender)
    {
       if(message!=EmptyStr)
       {
          Label1->Caption = message;
          message=EmptyStr;
       }
    }
    //---------------------------------------------------------------------------
    


  • Nee, das mit dem Timer ist Quatsch, weil so erstens Messages unterschlagen werden könnten, die wichtig sind, und zweitens sollte der Anwender doch wissen, was das Programm direkt gerade macht, und nicht erst nach 1 bis 2 Sekunden. Vor allem, wird der User betrogen, wenn da "Performing Search..." oder so steht, was aber gerade vor 2 Sekunden der Fall war.
    Wenn die Nachrichten so schnell reinkommen, dass man sie nicht lesen kann, dann ist so ein Label eh Blödsinn. Es erfüllt seinen Zweck nicht: Information des Users. Wenn du keinen Platz hast, dann mach dir dafür eben ein Extra-Fenster und darein ne ListBox o.ä. Oder zeig eben keine Infos an und erstelle ein LogFile, wie oben bereits vorgeschlagen.



  • WebFritzi schrieb:

    Nee, das mit dem Timer ist Quatsch, weil so erstens Messages unterschlagen werden könnten, die wichtig sind, und zweitens sollte der Anwender doch wissen, was das Programm direkt gerade macht, und nicht erst nach 1 bis 2 Sekunden.

    Wer sagt denn bitte, dass der Timer 1-2 Sekunden Intervalle fahren soll? Ausserdem ist erfahrungsgemäss alles was eine schnellere Änderungsrate hat als 2Hz (0.5s Pause) unleserlich für den Benutzer und damit ohnehin uninteressant...



  • P.S: Entsprechend also ist der Ansatz mit dem Timer hier sicher nicht der dümmste. Die Version mit dem Sleep halte ich für etwas gewagt, da sie tatsächlich den ganzen Applikationsthread und damit die Verarbeitung der Nachrichtenschleife blockiert für 200ms. Ausser natürlich man verwendet eine Schleife mit dem Inhalt Sleep(1) und Application->ProcessMessages(). Das wiederum ist aber eine massiv ungenauere und umständlichere Variante als sie eigentlich nötig wäre. Denn genau für solche Fälle stellt Windows ja TimerCallbacks zur Verfügung.


Anmelden zum Antworten