MetaTrader 5 herunterladen

DRAW_COLOR_BARS

Stil DRAW_COLOR_BARS zieht Balken auf die Werte der vier Indikator-Puffer, die Preise Open, High, Low und Close erhalten. Dieser Stil ist eine erweiterte Version des Stils DRAW_BARS und ermöglicht Ihnen, die Farbe für jeden Balken aus einer vorgegebenen Satz von Farben anzugeben. Es erlaubt individuelle Indikatoren in Form von Balken, darunter ein in separates Grafikfenster und andere Finanzinstrumente, zu erstellen.

Balkenfarbe kann durch Compiler-Direktiven oder dynamisch mit der PlotIndexSetInteger()-Funktion angegeben werden. Dynamische Veränderungen in den Eigenschaften der graphischen Konstruktion ermöglichen es Ihnen, die Indikatoren zu "wiederbeleben" so, dass sie ihr Aussehen ändern je nach der aktuellen Situation.

Der Indikator ist nur für die Balken, fur die nicht leer Werte aller vier Indikator-Puffern angegeben wird, gezeichnet. Um anzugeben, welchen Wert als "leer" betrachtet werden soll, setzen Sie diesen Wert in der Eigenschaft PLOT_EMPTY_VALUE:

//--- Der Leerer Wert (0) wird nicht in der Zeichnung teilnehmen
   PlotIndexSetDouble(Index_der_Darstellung_DRAW_COLOR_BARS,PLOT_EMPTY_VALUE,0);

Immer füllen Sie die Indikator-Puffer mit Werten expliziert aus, geben Sie den leeren Wert in Puffer der Balken zu überspringen.

Die erforderliche Anzahl der Puffer für den Bau von DRAW_COLOR_BARS ist 5:

  • vier Puffer zum Speichern der Werte von Open, High, Low und Close;
  • einen Puffer, um die Farbindex des Balkens (es its sinnvoll nur für gezeichnete Balken) zu speichern.

Alle Puffer sollen eine nach der anderen in dieser Reihenfolge gehen: Open, High, Low, Close und Farbpuffer. Keiner der Preis-Puffer darf nicht nur leere Werte haben, da in diesem Fall nichts gezeichnet wird.

Ein Beispiel für einen Indikator, der Balken des Finanzinstrumenten in einem separaten Fenster zeichnet. Die Balkenfarbe wird zufällig alle N Ticks verändert. Der Parameter N wird in externen Parameter des Indikators angegeben, damit kann es manuell angegeben werden (die Registerkarte "Einstellungen" im Indikatoreigenschaften-Fenster).

Ein Beispiel von DRAW_COLOR_BARS

Bitte beachten Sie, dass für plot1 mit dem DRAW_COLOR_BARS-Stil ursprünglich acht Farben mit Compiler-Direktiven #property angegeben werden, und dann, in der OnCalculate()-Funktion, wird die Farbe nach dem Zufallsprinzip aus 14 Farben, die in Array colors[] gespeichert sind, ausgewählt.

//+------------------------------------------------------------------+
//|                                              DRAW_COLOR_BARS.mq5 |
//|                        Copyright 2011, MetaQuotes Software Corp. |
//|                                              https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2011, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"
 
#property description "Der Indikator demonstriert DRAW_COLOR_BARS"
#property description "Zeichnet in einem separaten Fenster verschiedenfarbige Balken des ausgewählten Symbols"
#property description "Die Farbe und Größe der Balken und der Symbol werden nach dem Zufallsprinzip "
#property description "jede N Ticks verändert
 
#property indicator_separate_window
#property indicator_buffers 5
#property indicator_plots   1
//--- plot ColorBars
#property indicator_label1  "ColorBars"
#property indicator_type1   DRAW_COLOR_BARS
//--- Definieren wir 8 Farben um Balken zu färben (sie sind im speziellen Array gespeichert)
#property indicator_color1  clrRed,clrBlue,clrGreen,clrYellow,clrMagenta,clrCyan,clrLime,clrOrange
#property indicator_style1  STYLE_SOLID
#property indicator_width1  1
//--- Eingabeparameter
input int      N=5;              // Anzahl der Ticks um Art zu ändern
input int      bars=500;         // Anzahl der Balken zu zeigen
input bool     messages=false;   // Ausgabe der Meldungen ins"Experts"-Journal
//--- Indicator-Puffer
double         ColorBarsBuffer1[];
double         ColorBarsBuffer2[];
double         ColorBarsBuffer3[];
double         ColorBarsBuffer4[];
double         ColorBarsColors[];
//--- Symbolname
string symbol;
int    bars_colors;
//--- Array, um die Farbe zu speichern, enthält 14 Elemente
color colors[]=
  {
   clrRed,clrBlue,clrGreen,clrChocolate,clrMagenta,clrDodgerBlue,clrGoldenrod,
   clrIndigo,clrLightBlue,clrAliceBlue,clrMoccasin,clrMagenta,clrCyan,clrMediumPurple
  };
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- indicator buffers mapping
   SetIndexBuffer(0,ColorBarsBuffer1,INDICATOR_DATA);
   SetIndexBuffer(1,ColorBarsBuffer2,INDICATOR_DATA);
   SetIndexBuffer(2,ColorBarsBuffer3,INDICATOR_DATA);
   SetIndexBuffer(3,ColorBarsBuffer4,INDICATOR_DATA);
   SetIndexBuffer(4,ColorBarsColors,INDICATOR_COLOR_INDEX);
//---- Anzahl der Farben um Balken zu färben
   bars_colors=8;   //  Sehen Sie. Kommentar zur Eigenschaft #property indicator_color1
//---
   return(INIT_SUCCEEDED);
 ;}
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
  {
   static int ticks=0;
//--- Zählen wir Ticks, um den Stil, die Farbe und Breite des Balkens zu ändern
   ticks++;
//--- Wenn eine ausreichende Anzahl von Ticks angesammelt hat
   if(ticks>=N)
     {
 //--- Wählen wir ein neues Symbol aus dem "Market Watch"
      symbol=GetRandomSymbolName();
      //--- Ändern wir die Eigenschaften der Linie
      ChangeLineAppearance();
 //--- Ändern wir die Farben der Balken
      ChangeColors(colors,bars_colors);
      int tries=0;
      //--- Machen wir 5 Versuche, um den Puffer mit Preise aus symbol zu füllen
      while(!CopyFromSymbolToBuffers(symbol,rates_total,bars_colors) && tries<5)
        {
         //--- Zähler der CopyFromSymbolToBuffers() Funktionsaufrufe
         tries++;
       ;}
      //--- Setzen wir den Zähler der Ticks auf Null
      ticks=0;
    ;}
//--- return value of prev_calculated for next call
   return(rates_total);
 ;}
//+------------------------------------------------------------------+
//| Füllen wir den Indikator-Puffer mit Preise aus                   |
//+------------------------------------------------------------------+
bool CopyFromSymbolToBuffers(string name,int total,int bar_colors)
  {
//--- In die Array rates[] kopieren wir Preise Open, High, Low und Close
   MqlRates rates[];
//--- Zähler der Versuche
   int attempts=0;
//--- Wie viel kopiert
   int copied=0;
//--- Machen wir 25 Versuche, um die Zeitreihe für das gewünschten Symbol zu erhalten
   while(attempts<25 && (copied=CopyRates(name,_Period,0,bars,rates))<0)
     {
      Sleep(100);
      attempts++;
      if(messagesPrintFormat("%s CopyRates(%s) attempts=%d",__FUNCTION__,name,attempts);
    ;}
//--- Wenn es gelang nicht eine ausreichende Anzahl von Balken zu kopieren
   if(copied!=bars)
     {
      //--- erstellen wir einen Nachrichtenstring
      string comm=StringFormat("Für Symbol %s konnte nur %d Balken von %d gefragten Balken erhalten",
                               name,
                               copied,
                               bars
                               );
      //--- Zeigen wir einer Nachricht in einer Kommentar auf dem Haupt-Chart-Fenster
      Comment(comm);
      //--- Anzeige von Informationen
      if(messagesPrint(comm);
      return(false);
    ;}
   else
     {
      //--- Einstellen wir Anzeige des Symbols 
      PlotIndexSetString(0,PLOT_LABEL,name+" Open;"+name+" High;"+name+" Low;"+name+" Close");
      IndicatorSetString(INDICATOR_SHORTNAME,"DRAW_COLOR_BARS("+name+")");
    ;}
//--- Initialisieren wir den Puffer leere Werte
   ArrayInitialize(ColorBarsBuffer1,0.0);
   ArrayInitialize(ColorBarsBuffer2,0.0);
   ArrayInitialize(ColorBarsBuffer3,0.0);
   ArrayInitialize(ColorBarsBuffer4,0.0);
 
//--- Kopieren wir Preise in Puffer
   for(int i=0;i<copied;i++)
     {
 //--- Berechnen wir den entsprechenden Index für den Puffer
      int buffer_index=total-copied+i;
 //--- Schreiben wir die Preise in Puffer
      ColorBarsBuffer1[buffer_index]=rates[i].open;
      ColorBarsBuffer2[buffer_index]=rates[i].high;
      ColorBarsBuffer3[buffer_index]=rates[i].low;
      ColorBarsBuffer4[buffer_index]=rates[i].close;
      //---
      ColorBarsColors[buffer_index]=i%bar_colors;
    ;}
   return(true);
 ;}
//+------------------------------------------------------------------+
//| Gibt ein zufälliges Symbol aus dem Market Watch zurück           |
//+------------------------------------------------------------------+
string GetRandomSymbolName()
  {
//--- Anzahl der in dem "Market Watch" Fenster angezeigten Symbole
   int symbols=SymbolsTotal(true);
//--- Position des Symbols in der Liste - eine Zufallszahl zwischen 0 und symbols
   int number=MathRand()%symbols;
//--- Gibt den Namen des Symbols an der angegebenen Position zurück
   return SymbolName(number,true);
 ;}
//+------------------------------------------------------------------+
//| Ändert die Farbe der Segmente des ZigZags                        |
//+------------------------------------------------------------------+
void  ChangeColors(color  &cols[],int plot_colors)
  {
//--- Anzahl der Farben
   int size=ArraySize(cols);
//--- 
   string comm=ChartGetString(0,CHART_COMMENT)+"\r\n\r\n";
 
//--- Für jede Farbeindex definieren wir eine neue Farbe zufällig
   for(int plot_color_ind=0;plot_color_ind<plot_colors;plot_color_ind++)
     {
      //--- erhalten wir eine Zufallszahl
      int number=MathRand();
      //--- Erhalten wir den Index in Array col[] als den Rest der ganzzahligen Division
      int i=number%size;
      //--- Geben wir die Farbe für jeden Index als Eigenschaft PLOT_LINE_COLOR an
      PlotIndexSetInteger(0,                    //  Nummer der Grafikstile
                          PLOT_LINE_COLOR,      //  Property Identifier
                          plot_color_ind,       //  Farbindex, in dem wir die Farbe schreiben
                          cols[i]);             //  neue Farbe
      //--- schreiben wir die Farbe
      comm=comm+StringFormat("BarColorIndex[%d]=%s \r\n",plot_color_ind,ColorToString(cols[i],true));
      ChartSetString(0,CHART_COMMENT,comm);
    ;}
//---
 ;}
//+------------------------------------------------------------------+
//| Ändert das Aussehen von Balken                                   |
//+------------------------------------------------------------------+
void ChangeLineAppearance()
  {
//--- String um Informationen über die Eigenschaften der Balken zu erstellen
   string comm="";
 
//--- Block mit Änderungen der Balkenbreite
   int number=MathRand();
//--- Erhalten wir die Breite als den Rest der ganzzahligen Division
   int width=number%5;   // Breite ist von 0 bis 4
//--- Geben wir die Farbe als Eigenschaft PLOT_LINE_WIDTH
   PlotIndexSetInteger(0,PLOT_LINE_WIDTH,width);
//--- Schreiben wir die Linienbreite
   comm=comm+"\r\nWidth="+IntegerToString(width);
 
//--- Schreiben wir den Namen des Symbols
   comm="\r\n"+symbol+comm;
 
//--- Zeigen wir Informationen auf dem Chart durch den Kommentar
   Comment(comm);
 ;}