MetaTrader 5 herunterladen

DRAW_COLOR_CANDLES

DRAW_COLOR_CANDLES-Stil, als DRAW_CANDLES zeichnet Kerzen auf den Werten der vier Indikator-Puffer, die die Preise Open, High, Low und Close enthalten. Aber außerdem, erlaubt es Ihnen, eine Farbe für jede Kerzen aus einer gegebenen Satz anzugeben. Zu diesem Zweck hat der Stil einen speziellen Farbpuffer, der Farbindizes für jeden Balken speichert. Es erlaubt individuelle Indikatoren in Form von Kerzen, darunter ein in separates Grafikfenster und andere Finanzinstrumente, zu erstellen.

Die Anzahl der Farben um die Kerzen zu färben 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 der 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_CANDLES,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_CANDLES ist 5:

  • vier Puffer zum Speichern der Werte von Open, High, Low und Close;
  • einen Puffer, um die Farbindex der Kerze (es its sinnvoll nur für gezeichnete Kerzen) 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 Kerzen des Finanzinstrumenten in einem separaten Fenster zeichnet. Die Kerzenfarbe 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_CANDLES

Bitte beachten Sie, dass für Plot1 die Farbe mit Compiler-Direktiven #property angegeben wird, und dann in der Funktion OnCalculate() wird die Farbe nach dem Zufallsprinzip aus einer vorbereiteten Liste ausgewählt.

//+------------------------------------------------------------------+
//|                                           DRAW_COLOR_CANDLES.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 zeigt DRAW_COLOR_CANDLES."
#property description "Zeichnet in einem separaten Fenster verschiedenfarbige Kerzen des ausgewählten Symbols"
#property description " "
#property description "Die Farbe und Größe der Kerzen 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 ColorCandles
#property indicator_label1  "ColorCandles"
#property indicator_type1   DRAW_COLOR_CANDLES
//--- Definieren wir 8 Farben um Kerzen 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 Kerzen zu zeigen
input bool     messages=false;   // Ausgabe der Meldungen ins"Experts"-Journal
//--- Indicator-Puffer
double         ColorCandlesBuffer1[];
double         ColorCandlesBuffer2[];
double         ColorCandlesBuffer3[];
double         ColorCandlesBuffer4[];
double         ColorCandlesColors[];
int            candles_colors;
//--- Symbolname
string symbol;
//--- 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()
  {
//--- wenn es gibt zu wenig bars, Arbeit früher vollenden
   if(bars<50)
     {
      Comment("Geben Sie eine größere Anzahl von Bars! Arbeit des Indikators ist beendet");
      return(INIT_PARAMETERS_INCORRECT);
    ;}
//--- indicator buffers mapping
   SetIndexBuffer(0,ColorCandlesBuffer1,INDICATOR_DATA);
   SetIndexBuffer(1,ColorCandlesBuffer2,INDICATOR_DATA);
   SetIndexBuffer(2,ColorCandlesBuffer3,INDICATOR_DATA);
   SetIndexBuffer(3,ColorCandlesBuffer4,INDICATOR_DATA);
   SetIndexBuffer(4,ColorCandlesColors,INDICATOR_COLOR_INDEX);
//--- Leerer Wert
   PlotIndexSetDouble(0,PLOT_EMPTY_VALUE,0);
//--- Name des Symbols, für das die Balken gezeichnet werden
   symbol=_Symbol;
//--- Einstellen wir Anzeige des Symbols
   PlotIndexSetString(0,PLOT_LABEL,symbol+" Open;"+symbol+" High;"+symbol+" Low;"+symbol+" Close");
   IndicatorSetString(INDICATOR_SHORTNAME,"DRAW_COLOR_CANDLES("+symbol+")");
//---- Anzahl der Farben um Kerzen zu färben
   candles_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=INT_MAX-100;
//--- Zählen wir Ticks, um den Stil und die 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();
      //--- Ansicht verändern
      ChangeLineAppearance();
 //--- Ändern wir die Farben der Balken
      ChangeColors(colors,candles_colors);
 
      int tries=0;
      //--- Machen wir 5 Versuche, um den Puffer plot1 mit Preise aus symbol zu füllen
      while(!CopyFromSymbolToBuffers(symbol,rates_total,0,
            ColorCandlesBuffer1,ColorCandlesBuffer2,ColorCandlesBuffer3,
            ColorCandlesBuffer4,ColorCandlesColors,candles_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üllt die angegebene Kerze                                       |
//+------------------------------------------------------------------+
bool CopyFromSymbolToBuffers(string name,
                             int total,
                             int plot_index,
                             double &buff1[],
                             double &buff2[],
                             double &buff3[],
                             double &buff4[],
                             double &col_buffer[],
                             int    cndl_colors
                             )
  {
//--- In die Array rates[] kopieren wir Preise Open, High, Low und Close
   MqlRates rates[];
//--- Zähler der Versuche
   int attempts=0;
//--- Wieviel 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(messages) Print(comm);
      return(false);
    ;}
   else
     {
      //--- Einstellen wir Anzeige des Symbols 
      PlotIndexSetString(plot_index,PLOT_LABEL,name+" Open;"+name+" High;"+name+" Low;"+name+" Close");
      IndicatorSetString(INDICATOR_SHORTNAME,"DRAW_COLOR_CANDLES("+symbol+")");
    ;}
//--- Initialisieren wir den Puffer leere Werte
   ArrayInitialize(buff1,0.0);
   ArrayInitialize(buff2,0.0);
   ArrayInitialize(buff3,0.0);
   ArrayInitialize(buff4,0.0);
//--- Kopieren wir Preise in den Puffer bei jedem Tick
   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
      buff1[buffer_index]=rates[i].open;
      buff2[buffer_index]=rates[i].high;
      buff3[buffer_index]=rates[i].low;
      buff4[buffer_index]=rates[i].close;
      //--- Geben wir die Kerzefarbe an
      int color_index=i%cndl_colors;
      col_buffer[buffer_index]=color_index;
    ;}
   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 der Kerzen                         |
//+------------------------------------------------------------------+
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,       //  Farbeindex, in dem wir die Farbe schreiben
                          cols[i]);             //  neue Farbe
      //--- schreiben wir die Farbe
      comm=comm+StringFormat("CandleColorIndex[%d]=%s \r\n",plot_color_ind,ColorToString(cols[i],true));
      ChartSetString(0,CHART_COMMENT,comm);
    ;}
//---
 ;}
//+------------------------------------------------------------------+
//| Ändert das Aussehen der Kerzen                                   |
//+------------------------------------------------------------------+
void ChangeLineAppearance()
  {
//--- String um Informationen über die Eigenschaften der Kerzen zu erstellen
   string comm="";
//--- Schreiben wir den Namen des Symbols
   comm="\r\n"+symbol+comm;
//--- Zeigen wir Informationen auf dem Chart durch den Kommentar
   Comment(comm);
 ;}