Erros, bugs, perguntas - página 2916

[Kira27]

Kira27:

Como os nomes são idênticos, selecciona-se o primeiro dígito mais pequeno do número e é o 4º objecto, depois como os 2 primeiros objectos têm um 4º dígito, selecciona-se o dígito mais pequeno após o 4º dos 2 primeiros objectos.

A100:

Sim, apenas a conversão inversa não pode ser feita. Atribuir números aleatórios a objectos é como chamar a linguagem MQL831 em vez de MQL5.

Na minha opinião, para processar manualmente os objectos na ordem da sua criação, é necessário numerar os nomes depois de todos eles ou durante o processo de criação de cada um deles e depois executar o robot para processar e escrever o array mantendo a numeração da criação nos nomes. Isto permitirá no futuro uma classificação correcta dos objectos da lista como na funçãoObjectName e outros como ela, na ordemde criação dos objectos manualmente.

[Artyom Trishkin]

Kira27:

Na minha opinião, para processar objectos por ordem de criação manualmente, precisamos de numerar os nomes depois de todos os objectos terem sido criados ou no processo de criação de cada objecto e depois ligar o robô, que processa e escreve um array mantendo a numeração da criação nos nomes. No futuro, isto permitirá seleccionar correctamente objectos da lista, tanto através da função ObjectName como de outros como ela, por ordemde criação manualde objectos.

Porque não usar ObjectGetInteger() com identificador de propriedade OBJPROP_CREATETIME?

[Kira27]

Artyom Trishkin:

O que me impede de usar ObjectGetInteger() com identificação de propriedade OBJPROP_CREATETIME ?

A ideia é que quero que tudo o que desenho no gráfico seja escrito no nome dos objectos, incluindo a numeração da criação de objectos na lista, na ordem de criação, no tempo, no tipo de nível Fibo e no número de série do tipo Fibo, ao mesmo tempo que escrevo arrays com estes dados de nível na ordem em que são listados.

Até agora, encontrei esta forma: criamos 4 objectos Fibo Na lista, a ordem de criação é guardada, numerando-os para processamento de acordo com a ordem de criação Executar o Expert Advisor

//+------------------------------------------------------------------+
//|                                                            F.mq5 |
//|                        Copyright 2020, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2020, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"
//+------------------------------------------------------------------+
//|                                                  Fibo_Massiv.mq5 |
//|                        Copyright 2020, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
string NameFiboUp[15];                               // Объявление массива
string NameFiboDown[15];                               // Объявление массива
string NameFibo[9];                               // Объявление массива
int TimeFrame[9];
string Num[9];

int Frame;
//string New_N;




//+------------------------------------------------------------------+
int OnInit()
  {
//______________________________Массив новых имён с индексацией номеров очерёдности________________________________
   NameFiboUp[1]="FiboUp1 ";
   NameFiboDown[1]="FiboDown1 ";
   NameFiboUp[2]="FiboUp2 ";
   NameFiboDown[2]="FiboDown2";
   NameFiboUp[3]="FiboUp3";
   NameFiboDown[3]="FiboDown3 ";
   NameFiboUp[4]="FiboUp4 ";
   NameFiboDown[4]="FiboDown4 ";
   NameFiboUp[5]="FiboUp5";
   NameFiboDown[5]="FiboDown5 ";
   NameFiboUp[6]="FiboUp6 ";
   NameFiboDown[6]="FiboDown6 ";
   NameFiboUp[7]="FiboUp7 ";
   NameFiboDown[7]="FiboDown7 ";
   NameFiboUp[8]="FiboUp8 ";
   NameFiboDown[8]="FiboDown8 ";
   NameFiboUp[9]="FiboUp9 ";
   NameFiboDown[9]="FiboDown9 ";
   NameFiboUp[10]="FiboUp10 ";
   NameFiboDown[10]="FiboDown10";
   NameFiboUp[11]="FiboUp11 ";
   NameFiboDown[11]="FiboDown11 ";
   NameFiboUp[12]="FiboUp12 ";
   NameFiboDown[12]="FiboDown12 ";
   NameFiboUp[13]="FiboUp13 ";
   NameFiboDown[13]="FiboDown13";
   NameFiboUp[14]="FiboUp14 ";
   NameFiboDown[14]= "FiboDown14";
//____________________string Массив таймфреймов______________________________
   NameFibo[1]="M1";
   NameFibo[2]="M5";
   NameFibo[3]="M15";
   NameFibo[4]="H1";
   NameFibo[5]="H4";
   NameFibo[6]="Da";
   NameFibo[7]="We";
   NameFibo[8]="Mo";
//___________________int Массив таймфреймов__________________________________________
   TimeFrame[1]=1;
   TimeFrame[2]=5;
   TimeFrame[3]=15;
   TimeFrame[4]=60;
   TimeFrame[5]=240;
   TimeFrame[6]=1440;
   TimeFrame[7]=10080;
   TimeFrame[8]=43200;
//_____________________________________________________________________________
   Num[1]="1";
   Num[2]="2";
   Num[3]="3";
   Num[4]="4";
   Num[5]="5";
   Num[6]="6";
   Num[7]="7";
   Num[8]="8";

   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---

  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
   int G=0;
   int UP=1;    //Счётчик очерёдности типов фибо
   int Down=1;  //Счётчик очерёдности типов фибо
   string  nameUP   = "FiboUp";
   string  nameDown = "FiboDown";
   double FiboDown[4][10],FiboUp[4][10];  // 2x мерный  массив
//  Alert("ArraySize(FiboDown)= ", ArraySize(FiboDown));
   int Fibo_Koll = ObjectsTotal(0,0,OBJ_FIBO);     //Запрос колличества объектов Fibo

//_________________________________________________________
   if(Fibo_Koll==0) //Если нет не одного фибо выход        //
      return;                                              //
//_________________________________________________________//

 //  int Koll[];  //Индексация и запись в массив по порядку появления фибо в окне инструментов
  // int Tip[];    //Запись типа Fibo в массив по порядку появления фибо в окне инструментов
   //ArrayResize(Koll,Fibo_Koll); // Устанавливает новый размер в первом измерении массива Koll []
   //ArrayResize(Tip,Fibo_Koll);  // Устанавливает новый размер в первом измерении массива Tip []


//  ObjectName(0,0,0,OBJ_FIBO); //Вытаскивает имя найденого фибо

   for(int i=0; i < Fibo_Koll; i++)
     {
      G++; // Нумератор объектов из списка объектов
      string n =ObjectName(0,i,0,OBJ_FIBO); //Имя для обрезки до 2х первых знаков для получения тайм-фрейма
      string Name_Static =ObjectName(0,i,0,OBJ_FIBO);
      //--------------------------------------------------------

      //----------------------------------------------------------------------------------------
      double   Fibo_Level_0= ObjectGetDouble(
                                0,          // идентификатор графика
                                n,              // имя объекта
                                OBJPROP_PRICE,           // идентификатор свойства
                                0     // модификатор свойства
                             );


      double   Fibo_Level_1= ObjectGetDouble(
                                0,          // идентификатор графика
                                n,              // имя объекта
                                OBJPROP_PRICE,           // идентификатор свойства
                                1     // модификатор свойства
                             );
      //------------------------------------------------------------------------------------------------------
      if(Fibo_Level_0>Fibo_Level_1)
        {

         //вызов функции расчёта уровня 78.6
         double Fibo_78_Up = Function_Up(Fibo_Level_0, Fibo_Level_1);
         //Изменение имени объекта
         bool l =  StringSetLength(      //Устанавливает для  строки указанную длину в символах 2
                      n,       // строка
                      2    // новая длина строки
                   );
         //-----------------------------------------------------------
         int N = 1;
         string q;

         for(int e = 1; N != 0; e++) // пока N не == 0, гоняем функцию StringCompare. сравнивая обрезанную переменную(StringSetLength) с массивом NameFibo[]
           {
            N= StringCompare(
                  n,              // первая сравниваемая строка
                  NameFibo[e],    // вторая сравниваемая строка
                  true      // режим учета регистра букв при сравнении
               );

            q= NameFibo[e];
            Frame= TimeFrame[e];
           }
         string New_N =Num[G];
         string r= New_N+q+NameFiboUp[UP];


         //--------------------------------------------------------------------
         FiboUp[UP][1]=1;    // Тип обектов 1 == FiboUp
         FiboUp[UP][2]=UP;     // Нумерация обектов FiboUp по типу
         FiboUp[UP][3]=Fibo_78_Up;   // 78.6%
         FiboUp[UP][4]=Frame;       // Тайм фрейм
         FiboUp[UP][5]=0;         // 50%

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

         bool  F =ObjectSetString(0,Name_Static,OBJPROP_NAME,r);

         UP++;
        }
      //----------------------------------------------------------------------------------
      else
        {
         //вызов функции расчёта уровня 78.6
         double Fibo_78_Down = Function_Down(Fibo_Level_0, Fibo_Level_1);
         //Изменение имени объекта
         bool l =  StringSetLength(      //Устанавливает для  строки указанную длину в символах 2
                      n,       // строка
                      2    // новая длина строки
                   );
         //-----------------------------------------------------------
         int N = 1;
         string q;


         for(int e = 1; N != 0; e++) // пока N не == 0, гоняем функцию StringCompare. сравнивая обрезанную переменную(StringSetLength) с массивом NameFibo[]
           {
            N= StringCompare(
                  n,              // первая сравниваемая строка
                  NameFibo[e],    // вторая сравниваемая строка
                  true      // режим учета регистра букв при сравнении
               );

            q= NameFibo[e];
            Frame= TimeFrame[e];


           }
         string New_N =Num[G];
         string r= New_N+q+NameFiboDown[Down];

         //-------------------------------------------------------------------
         FiboDown[Down][1]=2;    // // Тип обектов 2 == FiboDown
         FiboDown[Down][2]=Down;     // Нумерация обектов  по типу
         FiboDown[Down][3]=Fibo_78_Down;   // 78.6%
         FiboDown[Down][4]=Frame;       // Тайм фрейм
         FiboDown[Down][5]=0;         // 50%
         //------------------------------------------------------------------
         //Изменение имени объекта
         bool  F =ObjectSetString(0,Name_Static,OBJPROP_NAME,r);
         Down++;
        }
     }
//+------------------------------------------------------------------+
   ArrayPrint(
      FiboUp,             // выводимый массив
      6,      // количество десятичных знаков после запятой
      NULL,      // разделитель между значениями полей структуры
      0,             // индекс первого выводимого элемента
      WHOLE_ARRAY,   // количество выводимых элементов
      ARRAYPRINT_HEADER|ARRAYPRINT_INDEX|ARRAYPRINT_ALIGN
   );

   ArrayPrint(
      FiboDown,             // выводимый массив
      6,      // количество десятичных знаков после запятой
      NULL,      // разделитель между значениями полей структуры
      0,             // индекс первого выводимого элемента
      WHOLE_ARRAY,   // количество выводимых элементов
      ARRAYPRINT_HEADER|ARRAYPRINT_INDEX|ARRAYPRINT_ALIGN
   );

  }
// for(int i=0; i<ArraySize(Koll); i++)
//  printf("Koll[%d] = %d",i,Koll[i]);


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

//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
double Function_Up(double a, double b)    // имя функции и список параметров
  {
   double Sum_100 = a - b; //Вычисляем 100% В пунктах от точек построения фибо
   double Sum_78  = Sum_100 * 78.6 / 100;  //Вычисляем 78.6% В пунктах
   return (Sum_78 + b);           // Вычисляем 78.6% в цене инструмента
  }
//+------------------------------------------------------------------+
double Function_Down(double a, double b)    // имя функции и список параметров
  {
   double Sum_100 = b - a ; //Вычисляем 100% В пунктах от точек построения фибо
   double Sum_78  = Sum_100 * 21.4 / 100;  //Вычисляем 78.6% В пунктах
   return (Sum_78 + a);           // Вычисляем 78.6% в цене инструмента
  }
//+------------------------------------------------------------------+

Percorremos os objectos na ordem da sua criação com mudança de nomes para manter a ordem de criação na lista, e escrevemos características e níveis de objectos em arrays na ordem da sua criação como na lista. O primeiro passe de código, mantendo a ordem de criação dos objectos na lista modifica os nomes, complementando com características de orientação ao criar critérios e mantendo a ordem na lista de objectos para uma correcta selecção posterior, passando pela ordem em caso de alteração das coordenadas dos objectos, e a correcta sobreposição de matrizes na ordem do primeiro preenchimento.

Até agora, a lógica é salva no primeiro passe))))

[Kira27]

Kira27:

A questão é que quero que tudo o que desenho no gráfico seja escrito em nome dos objectos, incluindo a numeração dos objectos da lista, por ordem de criação, período de tempo, tipo de nível de Fibo e número de série do tipo de Fibo, ao mesmo tempo que escrevo arrays com dados destes níveis na ordem dos objectos da lista de objectos gráficos.

Até ao momento, encontrei o seguinte método. Criamos 4 objectos Fibo na lista pela ordem da sua criação, numeramo-los para processamento de acordo com a ordem de criação Executar o Expert Advisor

A primeira passagem do código, mantendo a ordem dos objectos na lista, modifica os nomes dos objectos para manter a ordem da sua criação e registar características e níveis em matrizes na ordem de criação destes objectos como na lista. A primeira passagem do código, mantendo a ordem dos objectos na lista, modifica os nomes, acrescentando características para orientação ao criar critérios e mantendo a ordem na lista de objectos para uma correcta selecção posterior, tentando alterar a ordem dos objectos em caso de alteração de coordenadas e correcção da sobreposição de matrizes na ordem da primeira passagem

Enquanto no primeiro passe, a lógica é salva))))

Tudo seria muito mais fácil se os objectos tivessem um número na lista de objectos implicitamente atribuído a eles, que corresponderia à ordem em que foram criados.

[Nikolai Semko]

Nikolay Kositsin:
As pessoas que estão cientes disto, fizeram um esboço usando a classe CCanvas. E descobri um problema totalmente desconhecido. Os rectângulos de fundo preenchidos e os círculos são desenhados bem, mas todas as minhas tentativas de desenhar um círculo acabaram em completo fracasso. Há três variantes de círculos no código e nenhum resultado de desenhá-los no gráfico. Este código funciona para círculos ou falta alguma coisa?

Nikolai Semko:
Resultou sempre.

Está a fazer algo de errado.

Sim, tudo funciona.
Experimente este guião. Desenha em três algoritmos Circle, CircleAA, e CircleWu círculos de raios aleatórios, cor, e transparência

OCircleAA é melhor não usar - é um algoritmo muito lento.

[Artyom Trishkin]

Kira27:

Seria muito mais fácil se aos objectos fosse tacitamente atribuído um número na lista de objectos correspondente à ordem em que foram criados.

O momento da criação do objecto (usar OBJPROP_CREATETIME como o tipo ulong) não é um identificador da ordem de criação do objecto?

[Alexey Viktorov]

Kira27:

A questão é que quero que tudo o que desenho no gráfico seja escrito em nome dos objectos, incluindo a numeração dos objectos da lista, por ordem de criação, período de tempo, tipo de nível de Fibo e número de série do tipo de Fibo, em matrizes de escrita paralela com dados destes níveis na ordem dos objectos da lista de objectos gráficos. Depois criaremos critérios para acções comerciais por estes nomes, e dados em matrizes correspondentes à ordem de criação destes objectos.

Até ao momento, encontrei o seguinte método. Criamos 4 objectos Fibo na lista pela ordem da sua criação, numeramo-los para processamento de acordo com a ordem de criação Executar o Expert Advisor

A primeira passagem do código, mantendo a ordem dos objectos na lista, modifica os nomes dos objectos para manter a ordem da sua criação e registar características e níveis em matrizes na ordem de criação destes objectos como na lista. A primeira passagem do código, mantendo a ordem dos objectos na lista, modifica os nomes, acrescentando características para orientação ao criar critérios e mantendo a ordem na lista de objectos para uma correcta selecção posterior, tentando alterar a ordem das coordenadas dos objectos e escrever correctamente por cima das matrizes na primeira passagem

Enquanto na primeira passagem, a lógica é preservada))))

A sua pergunta é resolvida em "uma vez". É suficiente escrever a renomeação dos objectos criados.

/*******************Expert initialization function*******************/
int OnInit()
 {
  ChartSetInteger(ChartID(), CHART_EVENT_OBJECT_CREATE, true);
  return(INIT_SUCCEEDED);
 }/******************************************************************/

/***********************OnChartEvent function************************/
void OnChartEvent(const int id,         // идентификатор события
                  const long& lparam,   // параметр события типа long
                  const double& dparam, // параметр события типа double
                  const string& sparam  // параметр события типа string
                 )
 {
  if(id == CHARTEVENT_OBJECT_CREATE)
   {
    string result[];      //  массив для получения строк
    StringSplit(sparam, ' ', result); //  получим из имени созданного объекта подстроки
    ulong timeCreate = ObjectGetInteger(0, sparam, OBJPROP_CREATETIME); //  получим время создания объекта
    string newName = result[0]+" "+result[1]+" "+string(timeCreate); //  сформируем новое имя объекта
    ObjectSetString(0, sparam, OBJPROP_NAME, newName);  //  переименуем объект
   }
 }/******************************************************************/

Agora cada vez que se cria um objecto gráfico no gráfico com um Expert Advisor instalado, os nomes dos objectos terão o tempo de criação em vez de um número aleatório no nome e serão ordenados estritamente na sequência de criação.

[Oleksandr Nozemtsev]

Olá a todos! Podem aconselhar a um "programador" analfabeto o que acrescentar ao código do indicador em mql4, para sobrepor o histograma no gráfico de um instrumento num determinado local? É também desejável que o histograma seja semi-transparente, de modo a não cobrir o gráfico. No ficheiro anexado (não sei como anexá-lo à mensagem como imagem) mostrei-vos aproximadamente como deve ser.

[Kira27]

Alexey Viktorov:

A sua pergunta é resolvida num instante. É suficiente escrever a renomeação dos objectos criados.

Agora cada vez que se cria um objecto gráfico no gráfico com o Expert Advisor instalado, os nomes dos objectos em vez de um número aleatório, no nome terão a hora da criação e serão ordenados estritamente na sequência da criação.

Muito obrigado!!! não lido completamente sobre estas Funções de Tratamento de Eventos, simplificar a vida de um proger)

[Kira27]

Artyom Trishkin:
O tempo de criação do objecto (usar como tipo ulong) OBJPROP_CREATETIME não é um identificador da ordem de criação do objecto?

Sim! Obrigado!!!