Galerie der in MQL geschriebenen UIs - Seite 70

Neuer Kommentar
 
Das können Sie verstehen.
 
Jin Rong Xia #:
Sie können das verstehen.
Ja, ich kann Sie verstehen. Der Übersetzer arbeitet gut.
 

Thema 14.3: Anzeige gefährlicher Werte durch Blinken von Teilen von Elementen (Rahmen, Sockel, Text, Schieberegler und Schiebetafeln).

Das Blinken von Elementen ist eine hervorragende Ergänzung zur Farbanzeige, die den Übergang von Parametern in den Bereich der gefährlichen Werte signalisiert. Die Umsetzung der neuen Lösung ähnelt der bisherigen, aber wenn die Farbanzeige nach dem Prinzip funktioniert, dass die Farbe umso heller ist, je näher der Wert am kritischen Wert liegt, erhöht das Blinken nur die Häufigkeit des Wechsels der Ausgangsfarbe mit der für das Blinken eingestellten Farbe. Der Benutzer kann die Blinkverzögerung programmatisch einstellen, indem er sie schrittweise auf 25 ms verringert oder auf 2,5 Sekunden erhöht. In diesem Fall können beide Mechanismen gleichzeitig betrieben werden. Die Farbe wechselt von Hellgrün zu Hellrot und Burgunderrot, und das Blinken wird schneller. Der eine Mechanismus stört den zweiten nicht. Als nächstes werden wir praktische Beispiele aufschlüsseln.

*Wichtig: Das Blinken wird unabhängig von den Funktionen der Farbanzeige aktiviert. Die beiden Mechanismen sind technisch nicht miteinander verbunden und können parallel oder getrennt funktionieren.

Um das Blinken zu implementieren, wurden den interaktiven Elementen neue Eigenschaften hinzugefügt:

  • pn_BLINK_frame -. Blinkender Rahmen Wird zu allen Steuerelementen hinzugefügt, die einen Rahmen haben. Die folgenden Elemente sind ausgeschlossen: H_SLIDER, V_SLIDER, VALUE , R_BUTTON, CHECKBOX.
  • pn_ BLINK_text - . Blinkender Text Wird allen Elementen hinzugefügt, die Text enthalten. Ausgenommen sind Elemente: P_BAR, D_BAR, H_SLIDER, V_SLIDER.
  • pn_BLINK_base - Blinkende Basis Wird zu allen Elementen hinzugefügt, die eine Basis haben. Die folgenden Elemente sind ausgeschlossen: CHECKBOX, R_BUTTON, D_LIST, C_LIST, VALUE.
  • pn_BLINK_bar - BlinkenderBalken. Zugefügt zu Elementen mit einem Balken: P_BAR , D_BAR,H_SLIDER, V_SLIDER.
  • pn_BLINK_handle - Blinken des Schiebereglers. H_SLIDER, V_SLIDER Schieberegler hinzugefügt .


Neue Eigenschaften hinzugefügt, um Geschwindigkeit und Stopp des Blinkens zu kontrollieren:

  • pn_BLINK_DELAY - Blinzelverzögerung, zu allen Hauptelementen ohne Ausnahme hinzugefügt. *Wichtig - die Verzögerung wird für alle blinkenden Teile des Elements eingestellt und kann sich nicht von einem Teil zum anderen unterscheiden. Alle Teile des Elements mit softwareaktiviertem Blinken (es kann mehrere davon geben) blinken synchron. Die Blinkgeschwindigkeit zwischen den Elementen kann jedoch unterschiedlich sein und liegt ganz im Ermessen des Benutzers.
  • pn_BLINK_STOP DerBefehl , der das Blinken aller Komponenten des Elements vollständig stoppt.
  • Zum jetzigen Zeitpunkt ist es möglich, das Blinken des Rahmens des Einstellungsfensters zu aktivieren. Dazu müssen Sie die Funktion window aufrufen und ihr den Bezeichner der Eigenschaft pn_BLINK_frame übergeben . Und die Farbe. Alles ist genau dasselbe wie bei den Elementen.

Fassen wir das oben Gesagte zusammen:

  • Die Blinkverzögerung pn_BLINK_DELAY wird programmatisch festgelegt und wird auf alle blinkenden Teile des Elements gleichzeitig angewendet. Sie blinken synchron.
  • Die Eigenschaft pn_BLINK_DELAY hat einen Standardwert. Wenn sie nicht ausdrücklich vom Benutzer festgelegt wird, beträgt die Blinkverzögerung 20, also etwas mehr als eine Sekunde (20*25ms).
  • Ein Element kann mehrere Teile auf einmal oder einen Teil auf einmal blinken lassen. Die Entscheidung darüber trifft der Benutzer.
  • Während des Blinkens ist es möglich, die Farbe programmatisch zu ändern und die Geschwindigkeit anzupassen. Die Blinkfunktionen werden weiter unten besprochen.
  • Um einen anderen Teil des Elements blinken zu lassen, müssen Sie die Funktion aufrufen und den Bezeichner des Elementteils und die Farbe übergeben. Wenn aber z.B. ein Rahmen blinkt und der Benutzer möchte, dass der Text mit dem gewünschten Wert blinkt und der Rahmen aufhört zu blinken, muss das Blinken mit dem Befehl pn_BLINK_STOP vollständig ausgeschaltet und das Blinken des Textes durch einen Programmaufruf wieder eingeschaltet werden.
  • Auf Wunsch des Benutzers können die Komponenten des Elements in verschiedenen Farben blinken. So kann z.B. der Text in grün, der Rahmen in blau und der Sockel in rot blinken. Es stehen verschiedene Varianten zur Verfügung. Aber zur Erinnerung: Die Blinkgeschwindigkeit aller Teile eines Elements ist gleich.
  • Wenn ein Fenster minimiert ist und seine Registerkarte auf der Taskleiste liegt und es blinkende Elemente im Fenster gibt, wählt die Registerkarte automatisch das am schnellsten blinkende Element im geschlossenen Fenster aus (es wird nicht neu gezeichnet, wenn das Fenster geschlossen ist) und passt sich dessen Frequenz und Farbe an. Das heißt, die Registerkarten auf der Taskleiste blinken in der Farbe und Geschwindigkeit des am schnellsten blinkenden Elements in ihrem Fenster. Wenn jedoch Elemente ihre Blinkgeschwindigkeit ändern, während sie Werte empfangen, dann baut sich die Registerkarte automatisch neu auf, indem sie ein anderes Element findet und dessen Blinkgeschwindigkeit und Farbe ändert.
  • Wird das Blinken der Elemente im Fenster vollständig ausgeschaltet, hört die Registerkarte automatisch auf zu blinken.

Morgen werden wir zu praktischen Beispielen übergehen.

Heute nur eine kleine Demo, um zu verstehen, worüber wir sprechen.



Leider kommt es bei der Aufnahme zu Verzögerungen. Der Prozessor wird geladen. Aber die Demo zeigt, dass die Elemente asynchron und mit unterschiedlicher Geschwindigkeit blinken. Verschiedene Teile der Elemente blinken auch. All dies wird programmatisch eingestellt. Und die Registerkarte auf der Taskleiste fand automatisch das am schnellsten blinkende Element und wurde blau. Als das Element dann weniger oft zu blinken begann, fand es das andere, am schnellsten blinkende Element und wurde rot.

Wir werden dies morgen genauer untersuchen.

P.S. Wir werden auch Optionen für die Verwendung dieser sehr nützlichen Funktionen besprechen.

 


Anknüpfend an das gestrige Thema...

Heute werden wir das Thema Blinken von Elementen konzeptionell zusammenfassen und abschließen.

Gestern habe ich das Blinken nur im Zusammenhang mit der Signalisierung gefährlicher Werte betrachtet, aber die Anwendung kann viel breiter sein. Hier ist ein Beispiel:

Stellen wir uns einen Multiwährungs-Expert Advisor vor, der die Situation auf mehreren Marktplätzen analysiert. Nehmen wir an, er wählt die optimalen Einstiegs- und Ausstiegspunkte nach einer Reihe komplexer Kriterien aus. Der Expert Advisor arbeitet im halbautomatischen Modus und der Händler kann oder will nicht die gesamte Logik der Handelsstrategie programmieren. Sein Roboter überwacht die Märkte, sammelt Daten und informiert über wichtige Punkte. Die Arbeit des Experten beschränkt sich auf die Analyse und die Darstellung der Ergebnisse in Tabellen und Diagrammen. Die endgültige Entscheidung über die Transaktionen wird von einem Menschen getroffen.

Bei dieser Variante besteht die Handelstätigkeit darin, Datenströme in Echtzeit zu beobachten und die laufenden Wertreihen in benutzerdefinierte Parameter zu packen. Letztere helfen, das Situationsbewusstsein zu steigern.

Ein Live-Engagement erfordert jedoch zeitnahe Entscheidungen. Das Problem entsteht, wenn die Analyseergebnisse in verschiedenen Fenstern durch mehrere grafische Ansichten angezeigt werden. Die Menge der zu beachtenden Informationen wächst und der Fokus der Aufmerksamkeit teilt sich. Infolgedessen vernebelt sich die Marktperspektive im Kopf des Händlers und die Effizienz seiner Arbeit nimmt ab. Müdigkeit stellt sich ein.

In diesem Fall sind blinkende Elemente eine gute Hilfe:

  • Sie signalisieren die Dringlichkeit, Entscheidungen zu treffen oder Maßnahmen zu ergreifen.
  • Es informiert über die Geschwindigkeit der eintretenden Veränderungen.
  • Informiert über die Relevanz der beobachteten Ereignisse.
  • Informiert über die Bedeutung der erzielten Ergebnisse: Zahlen, Differenzen, Bereiche, Summen, Grenzwerte usw.

Zusammengefasst:
  • Das Blinken kann erinnern, warnen, informieren, signalisieren oder anzeigen.
  • Blinken schärft die Aufmerksamkeit und erhöht die Konzentration des Händlers.
  • Häufigkeit und Farbe bestimmen die Dringlichkeit von Entscheidungen oder Handlungen.
  • Kombiniert mit einem Farbwechsel erhöht das Blinken die Interaktivität der GUI und die Effizienz des Händlers.

Kommen wir nun zu einer praktischen Aufschlüsselung der neuen Funktionen:

  • 1. Legen wir die Reihenfolge der vorbereitenden Maßnahmen fest.
  • 2. Aktivieren wir das Blinken des Schaltflächenrahmens beim Drücken und deaktivieren wir das Blinken beim Nichtdrücken.
  • 3. Schalten wir das Blinken des Tastentextes ein.
  • 4. Schalten wir das Blinken des Knopfsockels ein.
  • 5. Verbinden wir mehrere andere Elemente mit dem Blinken der Schaltfläche: ein Feld mit Schaltflächen, ein Schieberegler, ein Kontrollkästchen und andere.
  • 6. Schalten wir das Blinken des Fensterrahmens ein.
  • 7. Verbinden wir die Blinkgeschwindigkeit der Elemente mit dem Wert des Schiebereglers und des Feldes mit den Schaltflächen.

//----------------------------------------------------------------------------------------------------------

1. Reihenfolge der vorbereitenden Aktionen:

  • Zuerst schreiben wir Wrapper für die Funktionen Blink_start() und Blink_stop(), die das Blinken der Elemente ein- und ausschalten sollen, wenn sie aufgerufen werden.
  • Die Funktion Blink_start() wird für das Einschalten verantwortlich sein. Sie wird bei einem Druckereignis aufgerufen. Die Funktion Blink_stop() ist für das Ausschalten des Blinkens verantwortlich. Sie wird aufgerufen, wenn die Schaltfläche "Start" gedrückt wird .
  • Suchen wir die Schaltfläche in der API-Datei und schreiben wir den Aufruf der Funktion Blink_start() beim Drücken der Schaltfläche und den Aufruf der Funktion Blink_stop() beim Drücken der Schaltfläche. 
//-----------------------------------------------------
//This function will start the blinking of the elements.
//-----------------------------------------------------
void Blink_start()
{

}
//-----------------------------------------------------
//This function will stop the blinking of the elements.
//-----------------------------------------------------
void Blink_stop()
{

}


Suchen wir nun den Fall der Schaltfläche "Start" in der API-Datei und schreiben wir die Aufrufe der Funktionen Blink_start() und Blink_stop() beim Drücken und beim Drücken der Schaltfläche:

case Settings_example_1___Start:
  
               //------------------------------------------------------------------------------------------------------
               //What to do when the button is pressed or released?
               //------------------------------------------------------------------------------------------------------
               switch((int)action)
               {
                case pressed:    Blink_start();  break;
  
                case released:   Blink_stop();   break;
               }
               //------------------------------------------------------------------------------------------------------
               //Your comment:
               //------------------------------------------------------------------------------------------------------
               break;


Fahren wir damit fort, die Funktionen mit Inhalt zu füllen:

1. Wir brauchen den Rahmen des "Start"-Buttons, um zu blinken. Schreiben wir einen Aufruf für das Blinken des Rahmens, wie im folgenden Code gezeigt. Der Bezeichner der Blink-Eigenschaft des Rahmens der Schaltfläche ist p1_BLINK_frame. Geben Sie die Farbe des Blinkens und das Objekt des Blinkens an.

void Blink_start()
{
 //Setting the color and the part of the element that is suppoused to blink.
 w6_i_p1_BUTTON_Start((int)clrLimeGreen,p1_BLINK_frame);
}


2. implementieren wir nun die Deaktivierung des Blinkens, wenn die Schaltfläche losgelassen wird. Der Bezeichner p1_BLINK_STOP ist für das Abschalten des Blinkens zuständig . Außer ihm brauchen Sie nichts in Klammern zu setzen.

void Blink_stop()
{
 //Stopping the blinking of all of the parts of the element all together:
 w6_i_p1_BUTTON_Start(p1_BLINK_STOP);
}


Testen wir das Ergebnis:



3. Schalten wir das Blinken des Schaltflächentextes anstelle des Rahmens ein. Der Bezeichner der Eigenschaft pn_BLINK_text ist für das Blinken des Textes verantwortlich:

void Blink_start()
{
 //Setting the color and the part of the element that is suppoused to blink.
 w6_i_p1_BUTTON_Start((int)clrRed,p1_BLINK_text);
}

Ergebnis: Der Text der Schaltfläche blinkt blau und hört auf zu blinken, wenn die Schaltfläche gedrückt wird.



4. Schalten wir nun das Blinken des Buttonsockels ein. Der Bezeichner der Eigenschaft pn_BLINK_base ist für die Basis zuständig:

void Blink_start()
{
 //Setting the color and the part of the element that is suppoused to blink.
 w6_i_p1_BUTTON_Start((int)clrRed,p1_BLINK_base);
}

Ergebnis: Die Basis der Taste blinkt rot und hört auf zu blinken, wenn sie gedrückt wird.



Kombinieren wir nun das Blinken des Rahmens der Schaltfläche und ihres Textes:

void Blink_start()
{
 //Setting the blinking of the frame and the text of the button
 w_6_Settings_example_1((int)clrRed,p8_BLINK_frame);
 w_6_Settings_example_1((int)clrRed,p8_BLINK_text);
}

Ergebnis: DerRahmen der Schaltfläche und der Text der Schaltfläche blinken synchron in verschiedenen Farben, wie vorgesehen.


5. Verbinden wir nun andere Elemente in diesem Fenster mit dem Blinken: 

void Blink_start()
{
 //Setting the color and the part of the element that is suppoused to blink.
 //-------------------------------------------------------------
 w6_i_p1_BUTTON_Start((int)clrLimeGreen,p1_BLINK_frame);
 w6_i_p1_BUTTON_Start((int)clrRed,p1_BLINK_text);
 //-------------------------------------------------------------
 w6_d_p5_S_EDIT_Spin_the_value((int)C'255,50,0',p5_BLINK_frame);
 w6_d_p5_S_EDIT_Spin_the_value((int)C'255,50,0',p5_BLINK_text);
 //-------------------------------------------------------------
 w6_i_p3_H_SLIDER_Roll_the_value((int)C'255,50,0',p3_BLINK_handle);
 w6_i_p3_H_SLIDER_Roll_the_value((int)C'255,50,0',p3_BLINK_bar);
 //-------------------------------------------------------------
 w6_i_p7_CHECKBOX_Set_an_option((int)C'255,50,0',p7_BLINK_text);
 //-------------------------------------------------------------
 w6_s_p6_D_LIST_D_LIST_1((int)C'255,50,0',p6_BLINK_frame);
 //-------------------------------------------------------------
}

Schreiben wir auch die Deaktivierung des Blinkens in die Funktion Blink_stop( ) : 

void Blink_stop()
{
 //Stopping the blinking
 //-------------------------------------------------------------
 w6_i_p1_BUTTON_Start(p1_BLINK_STOP);
 //-------------------------------------------------------------
 w6_d_p5_S_EDIT_Spin_the_value(p5_BLINK_STOP);
 //-------------------------------------------------------------
 w6_i_p3_H_SLIDER_Roll_the_value(p3_BLINK_STOP);
 //-------------------------------------------------------------
 w6_i_p7_CHECKBOX_Set_an_option(p7_BLINK_STOP);
 //-------------------------------------------------------------
 w6_s_p6_D_LIST_D_LIST_1(p6_BLINK_STOP);
 //-------------------------------------------------------------
}

Ergebnis: Die neuen Elemente sind in Blink_start() und Blink_stop() enthalten und blinken wie vorgesehen.


6. Lassen wir den Fensterrahmen blinken, wenn die Schaltfläche angeklickt wird. (Schalten wir das Blinken der nachlaufenden Elemente vorübergehend aus.)

void Blink_start()
{
//Setting the blinking of the frame of the window:
 w_6_Settings_example_1((int)clrRed,p8_BLINK_frame);
}

void Blink_stop()
{
//Stopping the blinking of the frame of the window:
 w_6_Settings_example_1(p8_BLINK_STOP);
}


Ergebnis: Der Fensterrahmen blinkt, wie er soll.


*Wichtig: alle betrachteten Elemente und der Fensterrahmen blinken mit der Standardgeschwindigkeit.

Weiter werden wir die Geschwindigkeit des Blinkens der Elemente mit dem Schieberegler und dem Feld mit den Schaltflächen regulieren.


7. Binden wir die Blinkgeschwindigkeit an den Wert im Feld mit den Schaltflächen und dem Schieberegler. Alle Elemente und der Fensterrahmen werden gleichzeitig blinken, und die Blinkgeschwindigkeit wird manuell durch diese Elemente eingestellt.

Ich möchte Sie daran erinnern, dass die Blinkgeschwindigkeit von der Verzögerung pn_BLINK_DELAY abhängt .

  • Die minimal mögliche Verzögerung ist 1, die maximal mögliche 99.
  • Um die Blinkverzögerungszeit zu berechnen, müssen Sie den Wert mit 25 (ms) multiplizieren.
  • Standardmäßig ist die Verzögerung gleich 20, also 500 Millisekunden (20*25ms).

Um das Problem zu lösen, gehen wir wie folgt vor:

  • 1. Wir bringen das Blinken aller Elemente beim Drücken/Freigeben einer Taste zurück und fügen das Blinken des Anruf-/Stoppfensters hinzu.
  • 2. Schreiben Sie eine neue Funktion Blink_delay(), in der wir Aufrufe platzieren werden, die eine Pause im Blinken festlegen. Die Funktion wird den Wert der Verzögerung akzeptieren.
  • 3. Schreiben wir einen Aufruf der Funktion Blink_delay() aus den Fällen der Schiebeelemente und des Eingabefeldes in der API-Datei, wobei der aktuelle Wert übergeben wird.

W ir haben das Blinken des Fensterrahmens innerhalb der Funktion Blink_start() hinzugefügt : . 

void Blink_start()
{
 //Setting the color and the part of the element that is suppoused to blink.
 //-------------------------------------------------------------
 w_6_Settings_example_1((int)clrRed,p8_BLINK_frame);
 //-------------------------------------------------------------
 w6_i_p1_BUTTON_Start((int)clrLimeGreen,p1_BLINK_frame);
 w6_i_p1_BUTTON_Start((int)clrRed,p1_BLINK_text);
 //-------------------------------------------------------------
 w6_d_p5_S_EDIT_Spin_the_value((int)C'255,50,0',p5_BLINK_frame);
 w6_d_p5_S_EDIT_Spin_the_value((int)C'255,50,0',p5_BLINK_text);
 //-------------------------------------------------------------
 w6_i_p3_H_SLIDER_Roll_the_value((int)C'255,50,0',p3_BLINK_handle);
 w6_i_p3_H_SLIDER_Roll_the_value((int)C'255,50,0',p3_BLINK_bar);
 //-------------------------------------------------------------
 w6_i_p7_CHECKBOX_Set_an_option((int)C'255,50,0',p7_BLINK_text);
 //-------------------------------------------------------------
 w6_s_p6_D_LIST_D_LIST_1((int)C'255,50,0',p6_BLINK_frame);
 //-------------------------------------------------------------
}

Wir haben das Deaktivieren des Blinkens des Fensterrahmens in der Funktion Blink_stop() hinzugefügt: 

void Blink_stop()
{
 //Stopping the blinking
 //-------------------------------------------------------------
 w_6_Settings_example_1(p8_BLINK_STOP);
 //-------------------------------------------------------------
 w6_i_p1_BUTTON_Start(p1_BLINK_STOP);
 //-------------------------------------------------------------
 w6_d_p5_S_EDIT_Spin_the_value(p5_BLINK_STOP);
 //-------------------------------------------------------------
 w6_i_p3_H_SLIDER_Roll_the_value(p3_BLINK_STOP);
 //-------------------------------------------------------------
 w6_i_p7_CHECKBOX_Set_an_option(p7_BLINK_STOP);
 //-------------------------------------------------------------
 w6_s_p6_D_LIST_D_LIST_1(p6_BLINK_STOP);
 //-------------------------------------------------------------
}

Schreiben der Funktion Blink_delay():

Rufen Sie die Funktion Blink_delay() für das Ereignis der Schieberegler- und Eingabefeldelemente auf und übergeben Sie ihr den aktuellen Wert der Elemente:

void Blink_delay(uint delay)
{
 if(delay > 0 && delay < 100)
   {
    //-------------------------------------------------------------
    w_6_Settings_example_1(delay,p8_BLINK_DELAY);
    //-------------------------------------------------------------
    w6_i_p1_BUTTON_Start(delay,p1_BLINK_DELAY);
    //-------------------------------------------------------------
    w6_d_p5_S_EDIT_Spin_the_value(delay,p5_BLINK_DELAY);
    //-------------------------------------------------------------
    w6_i_p3_H_SLIDER_Roll_the_value(delay,p3_BLINK_DELAY);
    //-------------------------------------------------------------
   }
else Print("Wrong value!");
}

*Wichtiger Hinweis: Es hat sich herausgestellt, dass es nicht möglich ist, die Blinkgeschwindigkeit der Checkbox- und Dropdown-Listenelemente zu ändern. Diese Geschwindigkeit ist immer gleich 20 (eine halbe Sekunde). Dies wurde absichtlich so gemacht, aber ich werde es wahrscheinlich in Zukunft ändern. Die anderen Elemente können die Blinkgeschwindigkeit ändern.

Schreiben wir einen Aufruf der Funktion Blink_delay() aus dem Ereignis des Elements "Spin_the_value" (das Feld mit den Schaltflächen). Das Feld ist mit dem Schieberegler verbunden, so dass es nicht notwendig ist, den Aufruf in das Schiebereglergehäuse zu setzen. Die Verbindung wird funktionieren und der Schieberegler ohne direkten Aufruf wird die Blinkgeschwindigkeit durch das Feld mit den Schaltflächen ändern:

case Settings_example_1___Spin_the_value:
  
               //------------------------------------------------------------------------------------------------------
               //What to do when the value is set?
               //------------------------------------------------------------------------------------------------------
               //Min value:  NOT SET  |   Max value:  NOT SET  |   V_step:  1.7  |   Default value:  468.99  |  Digits: 3
               //------------------------------------------------------------------------------------------------------
               w6_i_p3_H_SLIDER_Roll_the_value((int)value);
              
               //Сalling the blinking delay function
               Blink_delay((int)value);
               //------------------------------------------------------------------------------------------------------
               //Your comment:
               //------------------------------------------------------------------------------------------------------
               break;


Ergebnis: Das Feld mit den Schaltflächen und der Schieberegler ändern die Blinkgeschwindigkeit der Elemente im Fenster.



Ergebnisse:

  • Durch die Implementierung des Elementblinkens ist die Schnittstelle viel interaktiver und informativer als zuvor.
  • Die Methoden zum Aktivieren, Steuern und Deaktivieren des Elementblinkens sind sehr einfach und werden in zwei Beiträgen auf dieser Seite ausführlich beschrieben.
  • Die Methoden werden aufgelistet und mit Codebeispielen und Videos demonstriert.
  • Wahrscheinlich können in Zukunft noch einige Nuancen verfeinert oder hinzugefügt werden, aber im Großen und Ganzen sind die grundlegenden Blinkfunktionen bereits vorhanden und erfordern keine größeren Änderungen.
  • Sie können die Farbe des Blinkens ändern, während Sie den Wert des Elementparameters ändern.

Ich halte dieses Thema für erschöpft.


Der nächste Punkt auf der Liste - die Annullierung der eingegebenen Werte durch Drücken der Schaltfläche "Abbrechen".

 
Die nächste Version wird am Montag oder Dienstag nächster Woche veröffentlicht. Das Update wird die oben gezeigten Funktionen sowie die Stornierung/Bestätigung der Parametereingabe in den Einstellungsfenstern enthalten. Außerdem werden die Kataloge ins Englische übersetzt, und der Code wird anhand der Liste der identifizierten Probleme verbessert und behoben.
1...6364656667686970
Neuer Kommentar