MetaTrader 5 herunterladen

DRAW_COLOR_ARROW

Der DRAW_COLOR_ARROW-Stil zeichnet Pfeile (Zeichen aus dem Wingdings-Satz) der Farbe auf den Wert des Indikator-Puffers. Im Gegensatz zum Stil DRAW_ARROW, ist es möglich, die Farbe für jede Zeichen aus einer vordefinierten Gruppe von Farben, die durch die Eigenschaft indicator_color1 definiert werden, einzustellen.

Die Breite und die Farbe der Symbole können wie für DRAW_ARROW durch Compiler-Direktiven oder dynamisch mit der PlotIndexSetInteger()-Funktion angegeben werden. Dynamische Veränderungen in den Eigenschaften der graphischen Konstruktion ermöglichen es Ihnen, den Aussehens eines Indikators zu ändern je nach der aktuellen Situation.

Der Symbolcode wird mit der PLOT_ARROW-Eigenschaft eingegeben.

//--- Den Szmbolcode aus Wingdings-Satz für PLOT_ARROW definieren
   PlotIndexSetInteger(0,PLOT_ARROW,code);

Der Standardwert ist PLOT_ARROW=159 (Kreis).

Jeder Pfeil ist eigentlich ein Zeichen, dass die Höhe und den Ankerpunkt hat, und kann einige wichtige Information über den Chart (z. B. der Schlusskurs am Balken) bedecken. Daher können Sie optional den vertikalen Verschiebung in Pixel, die nicht auf der Skala des Charts abhängig ist, angeben. Bei dieser Anzahl von Pixeln werden die Pfeile visuell vertikal verschoben, obwohl der Wert des Indikators gleich bleiben wird:

//--- Definieren wir vertikale Verschiebung der Pfeile in Pixel
   PlotIndexSetInteger(0,PLOT_ARROW_SHIFT,shift);

Ein negativer Wert von PLOT_ARROW_SHIFT bedeutet Verschiebung des Pfeils nach oben, ein positiver Wert verschiebt den Pfeil nach unten.

DRAW_COLOR_ARROW-Stil kann in einem separaten Grafikfenster und im Hauptfenster verwendet werden. Leere Werte werden nicht gezeichnet und nicht in den "Data Window" angezeigt, alle Werte in Indikator-Puffern müssen explizit angegeben werden. Puffer werden nicht mit einem leeren Wert initialisiert.

//--- Leerer Wert setzen
   PlotIndexSetDouble(Index_der_Darstellung_DRAW_COLOR_ARROW,PLOT_EMPTY_VALUE,0);

Die erforderliche Anzahl der Puffer für den Bau von DRAW_COLOR_ARROW ist 4.

  • einen Puffer, um den Wert der Preis, auf den das Symbol gezeichnet wird (plus Verschiebung in Pixel, die in PLOT_ARROW_SHIFT-Eigenschaft angegeben wird), zu speichern;
  • einen Puffer, um die Farbindex des Pfeils (es its sinnvoll nur für Nicht-leere Werte) zu speichern.

Ein Beispiel des Indikators, der Pfeile auf jeder Balken, dessen Schlusspreis Close mehr als Schlusspreis des vorherigen Balkens ist, zeichnet. Die Breite, Verschiebung und Zeichencode aller Pfeile werden nach dem Zufallsprinzip jede N Ticks verändert. Die Symbolfarbe hängt von der Nummer des Balkens, auf der es gezeichnet wird, ab.

Ein Beispiel für den DRAW_COLOR_ARROW-Stil

In diesem Beispiel, für plot1 mit dem DRAW_COLOR_ARROW-Stil werden Farbe und Größe mithilfe Compiler-Direktive #property angegeben, und dann in der Funktion OnCalculate() werden Eigenschaften nach dem Zufallsprinzip angegeben. Der Parameter N wird in externen Parametern des Indikators angegeben, damit kann es manuell angegeben werden (die Registerkarte "Einstellungen" im Indikatoreigenschaften-Fenster).

Bitte beachten Sie, dass 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_ARROW.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_ARROW"
#property description "Auf dem Chart zeichnet es verschiedenfarbige Pfeile, die durch Unicode-Symbole definiert werden"
#property description "Die Farbe, Größe, Verschiebung und Zeichencode des Pfeils werden nach dem Zufallsprinzip"
#property description "jede N Ticks verändert."
#property description "Parameter code gibt den Basiswert an: Code=159 (Kreis)"
 
#property indicator_chart_window
#property indicator_buffers 2
#property indicator_plots   1
//--- plot ColorArrow
#property indicator_label1  "ColorArrow"
#property indicator_type1   DRAW_COLOR_ARROW
//--- Definieren wir 8 Farben um Histogramm nach Wochentag zu färben (sie sind im speziellen Array gespeichert)
#property indicator_color1  clrRed,clrBlue,clrSeaGreen,clrGold,clrDarkOrange,clrMagenta,clrYellowGreen,clrChocolate
#property indicator_style1  STYLE_SOLID
#property indicator_width1  1
 
//--- Eingabeparameter
input int      N=5;         // Anzahl der Ticks für Änderung
input ushort   code=159;    // Zeichencode zu zeichnen in DRAW_ARROW
int            color_sections;
//--- Indicator-Puffer
double         ColorArrowBuffer[];
//--- Puffer, um die Indexe der Farbe zu speichern
double         ColorArrowColors[];
//--- Array, um die Farbe zu speichern, enthält 14 Elemente
color colors[]=
  {
   clrRed,clrBlue,clrGreen,clrChocolate,clrMagenta,clrDodgerBlue,clrGoldenrod,
   clrIndigo,clrLightBlue,clrAliceBlue,clrMoccasin,clrWhiteSmoke,clrCyan,clrMediumPurple
  };
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- indicator buffers mapping
   SetIndexBuffer(0,ColorArrowBuffer,INDICATOR_DATA);
   SetIndexBuffer(1,ColorArrowColors,INDICATOR_COLOR_INDEX);
//--- Geben wir Zeichencode um in PLOT_ARROW zu zeichnen an
   PlotIndexSetInteger(0,PLOT_ARROW,code);
//--- Definieren wir vertikale Verschiebung der Pfeile in Pixel
   PlotIndexSetInteger(0,PLOT_ARROW_SHIFT,5);
//--- Setzen wir 0 als ein leerer Wert
   PlotIndexSetDouble(0,PLOT_EMPTY_VALUE,0);   
//---- Anzahl der Farben um die Sinuskurve zu färben
   color_sections=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 die Farbe, Größe, Verschiebung und Code des Pfeils zu ändern
   ticks++;
//--- Wenn eine kritische Anzahl von Ticks angesammelt hat
   if(ticks>=N)
     {
      //--- Ändern wir die Eigenschaften der Pfeile
      ChangeLineAppearance();
 //--- Ändern wir die Farben des Histogramms
      ChangeColors(colors,color_sections);
      //--- Setzen wir den Zähler der Ticks auf Null
      ticks=0;
    ;}
 
//--- Block mit Berechnung der Indikatorwerte
   int start=1;
   if(prev_calculated>0) start=prev_calculated-1;
//--- Berechnungzyklus
   for(int i=1;i<rates_total;i++)
     {
 //--- Wenn der aktuelle Close-Preis ist höher als der vorherige Close-price, dann setzen den Pfeil
      if(close[i]>close[i-1])
         ColorArrowBuffer[i]=close[i];
      //---Ansonsten geben einen leeren Wert an
      else
         ColorArrowBuffer[i]=0;
      //--- Pfeilfarbe
      int index=i%color_sections;
      ColorArrowColors[i]=index;
    ;}
//--- return value of prev_calculated for next call
   return(rates_total);
 ;}
//+------------------------------------------------------------------+
//| Ändert die Farbe der Linienteile                                 |
//+------------------------------------------------------------------+
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("ArrowColorIndex[%d]=%s \r\n",plot_color_ind,ColorToString(cols[i],true));
      ChartSetString(0,CHART_COMMENT,comm);
    ;}
//---
 ;}
//+------------------------------------------------------------------+
//| Ändert das Aussehen der angezeigten Linie im Indikator           |
//+------------------------------------------------------------------+
void ChangeLineAppearance()
  {
//--- String um Informationen über die Eigenschaften der Linie zu erstellen
   string comm="";
//--- Block mit Änderungen der Linienbreite
   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+" Width="+IntegerToString(width);
   
//--- Block mit Änderungen von Pfeilcode (PLOT_ARROW)
   number=MathRand();
//--- Erhalten wir den Rest aus Integer-Division, um den neuen Pfeilcode zu berechnen (von 0 bis 19)
   int code_add=number%20;
//--- Setzen wir einen neuen Zeichnencode als die Summe von code+code_add
   PlotIndexSetInteger(0,PLOT_ARROW,code+code_add);
//--- Schreiben wir den Zeichencode PLOT_ARROW
   comm="\r\n"+"PLOT_ARROW="+IntegerToString(code+code_add)+comm;   
 
//--- Block mit vertikaler Verschiebung der Pfeile in Pixel
   number=MathRand();
//--- Erhalten wir die Verschiebung als den Rest der ganzzahligen Division
   int shift=20-number%41;
//--- Einstellen wir wine neue Verschiebung von
   PlotIndexSetInteger(0,PLOT_ARROW_SHIFT,shift);
//--- Screiben wir die Verschiebung PLOT_ARROW_SHIFT
   comm="\r\n"+"PLOT_ARROW_SHIFT="+IntegerToString(shift)+comm;
 
//--- Zeigen wir Informationen auf dem Chart durch den Kommentar
   Comment(comm);
 ;}