Mises à jour : MetaTrader 5

Terminal

1. Calendrier Economique intégré complètement révisé.
   
   Le Calendrier Economique est notre solution propriétaire. Vous y trouverez plus de 600 nouvelles et indicateurs financiers relatifs aux 13 plus grandes économies mondiales : États-Unis, Union Européenne, Japon, Royaume-Uni, Canada, Australie, Chine, entre autres. Les données pertinentes sont collectées à partir de sources publiques en temps réel.
   
   La nouvelle version propose des contenus mis à jour et des filtres d'événement avancés : par heure, par priorité, par devise et par pays.
   
   Les données du calendrier sont accessibles depuis les programmes MQL5. Veuillez voir ci-dessous pour les détails.
   

   
   
   

   
   
2. Ajout du nouveau type d'applications MQL5 — les Services. Ce nouveau type permet de créer des flux de prix personnalisés pour le terminal, c’est-à-dire d’implémenter la livraison du prix depuis des systèmes externes en temps réel, tout comme il est implémenté sur les serveurs des courtiers.
   
   Contrairement aux Experts Advisors, aux indicateurs et aux scripts, les services ne sont pas liés à un graphique spécifique. Ces applications fonctionnent en arrière-plan et sont lancées automatiquement au démarrage du terminal (sauf si une telle application a été arrêtée de force).
   
   Les services peuvent être gérés à partir d'une nouvelle section de la fenêtre du Navigateur :
   

   
   
   

   
   
   Comment créer des services
   Pour créer un modèle de service, utilisez l'option MQL5 Wizard correspondante. Les services ont un point d'entrée Onstart, similaire aux scripts. A ce point, vous pouvez implémenter un cycle sans fin de réception et de traitement des données en utilisant des fonctions réseau.
   
   Comment lancer des services
   Pour exécuter plusieurs copies d'un Expert Advisor ou d'un indicateur avec différents paramètres, vous devez les lancer sur différents graphiques. Dans ce cas, différentes instances du programme sont créées, qui sont alors opérées indépendamment. Les services ne sont pas liés aux graphiques, donc un mécanisme spécial a été implémenté pour la création des instances de service.
   
   Sélectionnez un service depuis le Navigateur et cliqez sur "Ajouter le service" dans son menu contextuel. Une boîte de dialogue standard d'un programme MQL5, dans laquelle vous pouvez activer/désactiver le trading et l'accès aux signaux, ainsi que définir différents paramètres.
   

   
   
   
   

   Une instance de service peut être lancée et stoppée en utilisant le menu de l'instance correspondante. Pour gérer toutes les instances, utilisez le menu du service.
   
   
3. Un programme d'apprentissage a été implémenté.
   
   La nouvelle fonctionnalité aidera les débutants à apprendre comment interagir avec la plateforme. Nous avons ajouté plus de 100 astuces interactives sur les principales fonctionnalités de la plateforme.
   
   
   • Les astuces sont affichées comme une barre de progression sur la barre d'outils et ne distraient donc pas l'utilisateur.
   • Les astuces n'apparaissent que pour les actions que vous n'avez jamais effectué dans la plateforme.
     
   • Toutes les astuces incluent des liens interactifs, grâce auxquels vous pouvez naviguer vers les éléments de l'interface. Par exemple, une boîte de dialogue de trading ou un menu avec le programme désiré peut être lancé directement depuis l'astuce.
     
     
   Le remplissage de la barre de progression augmentera à chaque fois que vous effectuez des actions correspondantes et que vous contiuez la formation.
   

   
   
   

   
   
4. L'historique du compte de trading peut être présenté par positions. La plateforme collecte les données des transactions liées à la position (ouverture, augmentation du volume, clôture partielle ou totale) et groupe les informations dans un seul enregistrement. Vous pouvez donc accéder aux détails de la position : date et heure d'ouverture et de clôture, volume, prix et résultat. Cette forme plus efficace de présentation est maintenant disponible dans les rapports d'historique exportés vers les fichiers.

   
   
   

   
   
5. Ajout d'une nouvelle API permettant de requêter les données du terminal MetaTrader 5 aux travers d'applications en utilisant le langage R.
   
   Nous avons préparé un package spécial de MetaTrader. Il contient les DLL pour les interactions entre R et le terminal MetaTrader 5, la documentation et les fichiers r auxiliaires. Nous terminons l'enregistrement du package dans le dépôt CRAN, à la suite de quoi il sera disponible en téléchargement et pour être installé.
   

   
   
   

   
   Le package peut être installé avec une commande spéciale :
   
   R CMD INSTALL --build MetaTrader
   
   
   Les commandes suivantes liées à la demande de données sont disponibles :
   
   
   • MT5Initialize initialise et établit une connexion avec le terminal MetaTrader 5. Si nécessaire, le terminal est lancé pendant l'exécution de la commande.
   • MT5Shutdown désinitialise et se déconnecte de MetaTrader 5.
   • MT5Version retourne la version du terminal MetaTrader 5.
   • MT5TerminalInfo retourne l'état et les paramètres de la connexion du terminal au serveur d'un courtier (numéro du compte et adresse du serveur).
     
   • MT5WaitTerminal attend la connexion du terminal MetaTrader 5 au serveur d'un courtier.
   • MT5CopyTicksFrom(symbol, from, count, flags) copie le nombre spécifié de ticks en commencant à la date spécifiée. La date est spécifiée en millisecondes depuis le 01.01.1970.
   • MT5CopyTicksRange(symbol, from, to, flags) copie les ticks depuis la période spécifiée. Les dates sont spécifiées en millisecondes depuis le 01.01.1970.
   • MT5CopyRatesFrom(symbol, timeframe, from, count) copie le nombre spécifié de barres 1-minute en commencant à la date spécifiée. La date est spécifiée en secondes depuis le 01.01.1970.
   • MT5CopyRatesFromPos(symbol, timeframe, start_pos, count) copie les barres 1-minute depuis la position spécifiée relativement à la dernière barre.
     
   • MT5CopyRatesFromRange(symbol, timeframe, date_from, date_to) copie les barres depuis la période spécifiée. Les dates sont spécifiées en secondes depuis le 01.01.1970.
   
   La liste des commandes supportées sera augmentée dans le futur.
   
   
6. Optimisation de la boîte de dialogue Close By utilisée pour fermer une position par une position opposée. La boîte de dialogue n'est maintenant plus ralentie, même si vous avez un grand nombre de positions ouvertes.
7. Correction des erreurs de calcul des symboles synthétiques, en raison desquelles les données pouvaient être occasionnellement ignorées.
   
8. Lorsqu'un symbole personnalisé est supprimé, les fichiers stockant son historique des ticks et des barres sont également supprimés. Ceci évite d'accumuler des données non utilisées sur le disque dur.
9. Correction de l'affichage des résultats de recherche sur les écrans à haute résolution.

MQL5

1. Implémentation de l'accès aux données du calendrier économique depuis les programmes MQL5.
   
   Nouvelles fonctions
   
   CalendarCountryById — retourne la description d'un pays par son identifiant.
   

   bool CalendarCountryById(
      const long           country_id,    // identifiant du pays
      MqlCalendarCountry&  country        // description du pays
      );

   CalendarEventById — retourne la description d'un évènement par son identifiant.
   

   bool CalendarEventById(
      const long           event_id,      // identifiant de l'évènement
      MqlCalendarEvent&    event          // description de l'évènement
      );

   CalendarValueById — retourne le description de la valeur d'un évènement par son identifiant.
   

   bool CalendarValueById(
      const long           value_id,      // identifiant de la valeur
      MqlCalendarValue&    value          // description de la valeur
      );

   CalendarEventByCountry — retourne le tableau des évènements disponibles pour le pays.
   

   bool CalendarEventByCountry(
      string               country_code,  // code du pays
      MqlCalendarEvent&    events[]       // tableau d'évènements
      );

   CalendarEventByCurrency — retourne le tableau des évènements disponibles pour la devise affectée.
   

   bool CalendarEventByCurrency(
      string               currency,      // devise
      MqlCalendarEvent&    events[]       // tableau d'évènements
      );

   CalendarValueHistoryByEvent — retourne le tableau de valeurs pour la période de temps spécifiée, par identifiant d'évènement.
   

   bool CalendarValueHistoryByEvent(
      ulong                event_id,      // identifiant de l'évènement
      MqlCalendarValue&    values[],      // tableau de valeurs
      datetime             datetime_from, // date de début de période
      datetime             datetime_to=0  // date de fin de période
      );

   CalendarValueHistory — retourne le tableau de valeurs pour la période de temps spécifiée pour tous les évènements, filtrées par pays et/ou devise.
   

   bool CalendarValueHistory(
      MqlCalendarValue&    values[],          // tableau de valeurs
      datetime             datetime_from,     // début de période
      datetime             datetime_to=0,     // fin de période
      string               country_code=NULL, // code du pays
      string               currency=NULL      // devise
      );

   CalendarValueLastByEvent — retourne le tableau des valeurs des derniers évènements par identifiant. Cette fonction active la requête des valeurs qui sont apparues depuis la dernière requête. Le paramètre d'entrée/sortie "change_id" est en plus utilisé pour cette opération.
   
   Chaque fois que la base de données du calendrier change, la propriété "change_id" (l'identifiant du dernier changement) est mise à jour. Pendant la demande des données, vous spécifiez le "change_id" et le terminal retourne les évènements apparus après cette date, ainsi que la valeur courante du "change_id", qui peut être utilisée pour la prochaine requête. Au premier appel de fonction, spécifiez 0 comme "change_id" : la fonction ne retournera aucun évènement, mais retournera la valeur actuelle du "change_id" pour les demandes suivantes.
   

   bool CalendarValueHistory(
      ulong                event_id,          // identifiant de l'évènement
      ulong&               change_id,         // dernier change_id du calendrier
      MqlCalendarValue&    values[]           // tableau de valeurs
      );

   CalendarValueLast — retourne le tableau des dernières valeurs pour tous les évènements, filtrées par pays et/ou devise. Cette fonction active la requête des valeurs qui sont apparues depuis la dernière requête. De façon similaire à CalendarValueLastByEvent, la propriété "change_id" est utilisée pour la requête.
   

   bool CalendarValueHistory(
      ulong                event_id,          // identifiant de l'évènement
      ulong&               change_id,         // dernier change_id du calendrier
      MqlCalendarValue&    values[],          // tableau de valeurs
      string               country_code=NULL, // code du pays
      string currency=NULL                    // devise
      );

   
   Nouvelles structures
   
   MqlCalendarCountry — description du pays.
   

   struct MqlCalendarCountry
     {
      ulong             id;                        // identifiant du pays en ISO 3166-1
      string            name;                      // nom du pays
      string            code;                      // code du pays en ISO 3166-1 alpha-2
      string            currency;                  // code de la devise du pays
      string            currency_symbol;           // symbole/signe de la devise du pays
      string            url_name;                  // nom du pays dans les URL sur mql5.com
     };

   MqlCalendarEvent — description de l'évènement.
   

   struct MqlCalendarEvent
     {
      ulong                          id;           // identifiant de l'évènement
      ENUM_CALENDAR_EVENT_TYPE       type;         // type de l'évènement
      ENUM_CALENDAR_EVENT_SECTOR     sector;       // secteur auquel appartient l'évènement
      ENUM_CALENDAR_EVENT_FREQUENCY  frequency;    // fréquence de publication de l'évènement
      ENUM_CALENDAR_EVENT_TIMEMODE   time_mode;    // mode d'heure de publication de l'évènement
      ulong                          country_id;   // identifiant du pays
      ENUM_CALENDAR_EVENT_UNIT       unit;         // unité pour les valeurs de l'évènement
      ENUM_CALENDAR_EVENT_IMPORTANCE importance;   // importance de l'évènement
      ENUM_CALENDAR_EVENT_MULTIPLIER multiplier;   // multiplicateur de l'importance de l'évènement
      uint                           digits;       // nombre de décimales dans la valeur de l'évènement
      string                         source_url;   // URL source
      string                         event_code;   // code de l'évènement
      string                         name;         // texte de l'évènement dans la langue du terminal
     };

   MqlCalendarValue — description de la valeur de l'évènement.
   

   struct MqlCalendarValue
     {
      ulong             id;                        // identifiant de la valeur
      ulong             event_id;                  // identifiant de l'évènement
      datetime          time;                      // date et heure de l'évènement
      datetime          period;                    // période pour laquelle l'évènement est publié
      int               revision;                  // révision de l'indicateur publié en rapport avec la période de publication
      long              actual_value;              // valeur de l'évènement courant
      long              prev_value;                // valeur précédente de l'évènement
      long              revised_prev_value;        // valeur précédente révisée de l'évènement
      long              forecast_value;            // valeur prévue de l'évènement
      ENUM_CALENDAR_EVENT_IMPACRT impact_type;     // impact potentiel sur le taux de devise
     };

   
   Nouvelles énumérations
   
   

   enum ENUM_CALENDAR_EVENT_FREQUENCY
     {
      CALENDAR_FREQUENCY_NONE            =0,   // non utilisé
      CALENDAR_FREQUENCY_WEEK            =1,   // hebdomadaire
      CALENDAR_FREQUENCY_MONTH           =2,   // mensuel
      CALENDAR_FREQUENCY_QUARTER         =3,   // trimestriel
      CALENDAR_FREQUENCY_YEAR            =4,   // annuel
      CALENDAR_FREQUENCY_DAY             =5,   // quotidien
     };
   
   enum ENUM_CALENDAR_EVENT_TYPE
     {
      CALENDAR_TYPE_EVENT                =0,   // évènement (réunion, discours, etc.)
      CALENDAR_TYPE_INDICATOR            =1,   // indicateur
      CALENDAR_TYPE_HOLIDAY              =2,   // vacances
     };
   
   enum ENUM_CALENDAR_EVENT_SECTOR
     {
      CALENDAR_SECTOR_NONE               =0,   // aucun
      CALENDAR_SECTOR_MARKET             =1,   // marché
      CALENDAR_SECTOR_GDP                =2,   // PIB
      CALENDAR_SECTOR_JOBS               =3,   // emplois
      CALENDAR_SECTOR_PRICES             =4,   // prix
      CALENDAR_SECTOR_MONEY              =5,   // monnaie
      CALENDAR_SECTOR_TRADE              =6,   // commerce
      CALENDAR_SECTOR_GOVERNMENT         =7,   // gouvernement
      CALENDAR_SECTOR_BUSINESS           =8,   // affaires
      CALENDAR_SECTOR_CONSUMER           =9,   // consommateur
      CALENDAR_SECTOR_HOUSING            =10,  // logements
      CALENDAR_SECTOR_TAXES              =11,  // taxes
      CALENDAR_SECTOR_HOLIDAYS           =12,  // vacances
     };
     
   enum ENUM_CALENDAR_EVENT_IMPORTANCE
     {
      CALENDAR_IMPORTANCE_LOW            =0,   // aucune
      CALENDAR_IMPORTANCE_NONE           =1,   // basse
      CALENDAR_IMPORTANCE_MODERATE       =2,   // modérée
      CALENDAR_IMPORTANCE_HIGH           =3,   // haute
     };
   
   enum ENUM_CALENDAR_EVENT_UNIT
     {
      CALENDAR_UNIT_NONE                 =0,   // aucune
      CALENDAR_UNIT_PERCENT              =1,   // pourcentage
      CALENDAR_UNIT_CURRENCY             =2,   // devise nationale
      CALENDAR_UNIT_HOUR                 =3,   // nombre d'heures
      CALENDAR_UNIT_JOB                  =4,   // nombre d'emplois
      CALENDAR_UNIT_RIG                  =5,   // nombre de plateformes
      CALENDAR_UNIT_USD                  =6,   // dollar US
      CALENDAR_UNIT_PEOPLE               =7,   // nombre de personnes
      CALENDAR_UNIT_MORTGAGE             =8,   // nombre d'hypothèques
      CALENDAR_UNIT_VOTE                 =9,   // nombre de votes
      CALENDAR_UNIT_BARREL               =10,  // nombre de barils
      CALENDAR_UNIT_CUBICFEET            =11,  // volume en pieds cubes
      CALENDAR_UNIT_POSITION             =12,  // nombre d'offres d'emplois
      CALENDAR_UNIT_BUILDING             =13   // nombre d'immeubles
     };
     
   enum ENUM_CALENDAR_EVENT_MULTIPLIER
     {
      CALENDAR_MULTIPLIER_NONE           =0,   // aucun    
      CALENDAR_MULTIPLIER_THOUSANDS      =1,   // milliers
      CALENDAR_MULTIPLIER_MILLIONS       =2,   // millions
      CALENDAR_MULTIPLIER_BILLIONS       =3,   // milliards
      CALENDAR_MULTIPLIER_TRILLIONS      =4,   // milliards 
     };
     
   enum ENUM_CALENDAR_EVENT_IMPACRT
     {
      CALENDAR_IMPACT_NA                 =0,   // non disponible
      CALENDAR_IMPACT_POSITIVE           =1,   // positif
      CALENDAR_IMPACT_NEGATIVE           =2,   // négatif
     };
   
   enum ENUM_CALENDAR_EVENT_TIMEMODE
     {
      CALENDAR_TIMEMODE_DATETIME         =0,   // la source publie l'heure exacte
      CALENDAR_TIMEMODE_DATE             =1,   // l'évènement est sur la journée entière
      CALENDAR_TIMEMODE_NOTIME           =2,   // la source ne publie pas l'heure de l'évènement
      CALENDAR_TIMEMODE_TENTATIVE        =3,   // la source ne fournit que la date, et pas l'heure exacte en avance, l'heure exacte n'est ajoutée qu'après la survenue de l'évènement
     };

   
   Nouveaux codes d'erreurs
   
   

   ERR_CALENDAR_MORE_DATA             =5400,   // le tableau est trop petit pour le résultat entier (les valeurs qui tiennent dans le tableau sont passées)
   ERR_CALENDAR_TIMEOUT               =5401,   // time out suite à l'attente d'une réponse à la requête des données du calendrier
   ERR_CALENDAR_NO_DATA               =5402,   // données non trouvées

   
   
2. Corrections et améliorations de la vitesse d'exécution liées à l'historique des ticks et des barres.
3. Corrections et améliorations de la vitesse d'exécution liées aux fonctions de modification de l'historique des ticks et des barres des symboles personnalisés de trading, aux fonctions CustomTicks* et aux fonctions CustomRates*.
   
4. Nouvelles fonctions de conversion de données.
   
   CharArrayToStruct copie un tableau de uchar dans une structure POD.
   

   bool  CharArrayToStruct(
      void&         struct_object,    // structure
      const uchar&  char_array[],     // tableau
      uint          start_pos=0       // position de départ dans le tableau
      );

   StructToCharArray copie une structure POD dans un tableau de uchar.
   

   bool  StructToCharArray(
      const void&  struct_object,     // structure
      uchar&       char_array[],      // tableau
      uint         start_pos=0        // position de départ dans le tableau
      );

   
   
5. Ajout de la fonction MathSwap pour changer l'ordre des octets dans les valeurs ushort, uint et ulong.
   

   ushort MathSwap(ushort value);
   uint   MathSwap(uint   value);
   ulong  MathSwap(ulong  value);

   
   
6. Ajout des fonctions réseau pour créer des connexions TCP vers des hôtes distants via des sockets système :
   
   
   • SocketCreate crée une socket avec les flags spécifiés et retourne son handle
   • SocketClose ferme la socket
   • SocketConnect connecte au serveur, avec un contrôle du délai
   • SocketIsConnected vérifie si la socket est actuellement connectée
   • SocketIsReadable retourne le nombre d'octets pouvant être lus sur la socket
   • SocketIsWritable vérifie s'il est possible d'écrire actuellement des données sur la socket
   • SocketTimeouts définit les timeouts de réception et d'envoi des données pour l'objet socket système
   • SocketRead lit les données sur la socket
   • SocketSend écrit des données sur une socket
   • SocketTlsHandshake initie une connexion sécurisée TLS (SSL) avec l'hôte spécifié en utilisant le protocole TLS Handshake
   • SocketTlsCertificate reçoit les informations concernant le certificat utilisé pour la connexion sécurisée au réseau
   • SocketTlsRead lit les données depuis une connexion TLS sécurisée
   • SocketTlsReadAvailable lit toutes les données disponibles depuis une connexion TLS sécurisée
   • SocketTlsSend envoie les données en utilisant une connexion TLS sécurisée
   
   
   L'adresse de l'hôte, auquel la connexion avec les fonctions réseau est établie, doit être ajoutée explicitement à la liste des adresses autorisées dans les paramètres du terminal.
   
   
   De nouveaux codes d'erreurs ont été ajoutés pour l'utilisation des fonctions réseau :
   
   
   • ERR_NETSOCKET_INVALIDHANDLE (5270) : handle de socket invalide passé à la fonction
   • ERR_NETSOCKET_TOO_MANY_OPENED (5271) : trop de sockets ouvertes (maximum 128)
   • ERR_NETSOCKET_CANNOT_CONNECT (5272) : erreur de connexion à l'hôte distant
   • ERR_NETSOCKET_IO_ERROR (5273) : erreur d'envoi/de réception des données de la socket
   • ERR_NETSOCKET_HANDSHAKE_FAILED (5274) : erreur d'établissement de la connexion sécurisée (TLS Handshake)
   • ERR_NETSOCKET_NO_CERTIFICATE (5275) — aucune donnée sur le certificat utilisé pour la connexion sécurisée
   
   
7. Ajout de nouvelles fonctions pour l'utilisation des string :
   
   StringReserve réserve un buffer mémoire de la taille spécifiée pour une string.
   

   bool  StringReserve(
      string&        string_var,          // string
      uint           new_capacity         // taille de buffer pour la string
      );

   StringSetLength définit la longueur de chaîne spécifiée en caractères.
   

   bool  StringSetLength(
      string&        string_var,          // string
      uint           new_length           // nouvelle longueur de la chaîne
      );

   
   
8. Ajout d'une nouvelle fonction pour l'utilisation des tableaux :
   
   ArrayRemove supprime d'un tableau le nombre spécifié d'éléments en commencant à l'indice spécifié.
   

   bool  ArrayRemove(
      void&         array[],              // tableau de n'importe quel type
      uint          start,                // indice de départ de la suppression
      uint          count=WHOLE_ARRAY     // nombre d'éléments
      );

   ArrayInsert insère dans un tableau destination le nombre spécifié d'éléments du tableau source, en commencant à l'indice spécifié.
   

   bool  ArrayInsert(
      void&         dst_array[],          // tableau destination
      const void&   src_array[],          // tableau source
      uint          dst_start,            // indice dans le tableau destination où commencer l'insertion
      uint          src_start=0,          // indice dans le tableau source pour commencer la copie
      uint          count=WHOLE_ARRAY     // nombre d'éléments insérés
      );

   ArrayReverse inverse dans un tableau le nombre spécifié d'éléments en commencant à l'indice spécifié.
   

   bool  ArrayReverse(
      void&         array[],              // tableau de n'importe quel type
      uint          start=0,              // indice de début d'inversion
      uint          count=WHOLE_ARRAY     // nombre d'éléments
      );

   
   
9. Nouveau paramètre "uint count" ajouté dans les fonctions CustomRatesUpdate, CustomRatesReplace, CustomTicksAdd et CustomTicksReplace. Il permet de spécifié le nombre d'éléments du tableau passé, qui seront utilisés pour ces fonctions. La valeur WHOLE_ARRAY est utilisée par défaut pour le paramètre. Cela signifie que le tableau entier sera utilisé.
   
10. Ajout de la fonction CustomBookAdd pour passer le statut du Depth of Market pour un symbole personnalisé. La fonction permet de diffuser le Depth of Market comme si les prix arrivaient du serveur du courtier.
    

    int  CustomBookAdd(
       const string        symbol,            // symbol name
       const MqlBookInfo&  books[]            // an array with the DOM elements descriptions
       uint                count=WHOLE_ARRAY  // nombre d'éléments to be used
       );

11. Ajout de la surcharge de la fonction CustomSymbolCreate. Ceci permet la création d'un symbole de trading personnalisé à partir d'un symbole existant. Après la création, toute propriété du symbole peut être modifiée avec les fonctions correspondantes.
    

    bool  CustomSymbolCreate(
       const string        symbol_name,       // nom du symbole personnalisé
       const string        symbol_path="",    // nom du groupe dans lequel le symbole sera créé
       const string        symbol_origin=NULL // nom du symbole à partir duquel le symbole personnalisé sera créé
       );

    Le nom du symbole, à partir duquel les propriétés du symbole personnalisé seront copiées, sera spécifié dans le paramètre "symbol_origin".
    
    
12. La fonction StringToTime convertissant la string contenant une date/heure en une valeur de type datetime a été mise à jour. Elle supporte maintenant les formats de date suivants :
    
    
    • aaaa.mm.jj [hh:mi]
    • aaaa.mm.jj [hh:mi:ss]
    • aaaammjj [hh:mi:ss]
    • aaaammjj [hhmiss]
    • aaaa/mm/jj [hh:mi:ss]
    • aaaa-mm-jj [hh:mi:ss]
    
    
13. Nouvelle propriété TERMINAL_VPS dans l'énumération ENUM_TERMINAL_INFO_INTEGER ; elle montre que le terminal est en cours d'exécution sur le serveur d'Hébergement Virtuel MetaTrader (MetaTrader VPS). Si une application est en cours de fonctionnement sur un serveur d'hebergement, vous pouvez désactiver toutes ses fonctions visuelles, car le serveur virtuel n'a pas d'interface graphique utilisateur.
    
14. Nouvelle propriété SYMBOL_EXIST dans l'énumération ENUM_SYMBOL_INFO_INTEGER, signifie que le symbole derrière ce nom existe.
    
15. Correction de la saisie lors de l'utilisation des pré-déclarations des modèles de fonctions.
16. Ajout de la réinitialisation des indicateurs lors du changement du compte de trading.
    
17. Optimisation de la fonction StringSplit.
    
18. Correction d'erreurs dans l'utilisation de la bibliothèque standard.
    

Tester

1. Ajout de la fonction TesterStop — routine de fermeture prématurée d'un Expert Advisor sur un agent de test. Vous pouvez maintenant forcer la fin du test après avoir atteint le nombre spécifié de trades perdants, un niveau de drawdown prédéfini ou n'importe quel autre critère.
   
   Un test terminé avec cette fonction est considéré comme réussi. Après l'appel de la fonction, l'historique de trading obtenu pendant le test et toutes les statistiques de trades sont passés au terminal.
   
   
2. Désactivation de la possibilité de tester et d'optimiser les Expert Advisors via le MQL5 Cloud Network en mode de ticks réels. Ce mode ne peut être utilisé que sur les agents locaux et les fermes locales de réseaux.
   
3. Utilisation améliorée des indicateurs pendant un test visuel. Le graphique des prix et les lignes de l'indicateur sont maintenant dessinés de façon synchrone, même pour la vitesse maximum de visualisation.
   
4. Optimisation et accélération significative du test et de l'optimisation.
5. Correction du déboguage des indicateurs sur les données historiques. Maintenant, les fonctions OnInit et OnDeinit de l'indicateur peuvent être déboguée correctement.
6. Accès plus rapide aux données historiques lors du test des Expert Advisors multi-devises.
   
7. Correction du gel occasionnel du testeur visuel pendant le déboguage sur les données historiques.
8. Démarrage plus rapide des passes d'optimisation lors du traitement d'un ensemble de tâches par un agent.
9. Changement de la politique de distribution des ensembles de tâches vers les agents de test. La taille de l'ensemble a été augmentée et la consommation de ressources par les opérations réseau a été réduite significativement.
10. Changement du comportement des options permettant l'utilisation des agents locaux, du réseau et du cloud. Vous pouvez maintenant désactiver ces options, les agents complètement le traitement des tâches reçues, tandis qu'aucune nouvelle tâche ne leur est envoyée. Dans les versions précédentes, le comportement était similaire à la commande "Désactiver", qui stoppait immédiatement l'exécution de l'agent.
    

    
    
    

    
    

MetaEditor

1. Ajout du support des caractères non-ANSI dans le débogueur. Les expressions sont maintenant affichées correctement même si le nom de la variable est en cyrillique.
   
2. Correction de l'affichage des résultats de recherche sur les écrans haute résolution.

Ajout de la traduction de l'interface utilisateurs en croate.

La documentation a été mise à jour.

Terminal

1. Vous pouvez maintenant détacher les graphiques des symboles financiers de la fenêtre du terminal de trading.
   
   Cette fonctionnalité est pratique lors de l'utilisation de plusieurs écrans. Vous pouvez donc placer la fenêtre principale de la plateforme sur un écran pour contrôler l'état de votre compte, et placer vos graphiques sur un deuxième écran pour surveiller la situation du marché. Pour détacher un graphique du terminal, désactivez l'option Ancré dans son menu contextuel. Après cela, déplacez le graphique sur l'écran désiré.

   
   
   
   

   
   Une barre d'outils séparée sur les graphiques détachés permet d'appliquer les objets d'analyse et les indicateurs sans avoir à basculer d'écran. Utilisez le menu contextuel de la barre d'outil pour déterminer les commandes disponibles ou pour les cacher.
   
   
2. Mise à jour complète des chats intégrés. Ils supportent maintenant les conversations de groupe et les chaînes. Conduisez des discussions privées avec un groupe de personnes dans un environnement unifié sans basculer entre différentes fenêtres et créer des chaînes suivant vos intérêts et vos langues. Communiquez avec vos collègues et avec vos amis de la MQL5.community sans visiter le site web.
   
   Les chats de groupes et les chaînes peuvent être publics ou privés. Leurs créateurs décident s'il est possible de les rejoindre gratuitement ou seulement sur invitation. Vous pouvez également assigner des modérateurs aux chaînes et aux chats pour un contrôle supplémentaire des communications.
   

   
   
   

   
   
3. Ajout du support de la précision étendue du volume pour le trading des cryptomonnaies. Le volume minimum possible des opérations de trading est maintenant 0,00000001 lots. Le market depth, le time and sales, ainsi que d'autres éléments de l'interface comporte maintenant la possibilité d'afficher les volumes jusqu'à 8 décimales.
   
   Le volume minimal et son pas de change dépend des paramètres de l'instrument financier du côté du courtier.
   

   
   
   

   
   
4. Ajout de l'onglet des articles publiés sur la MQL5.community dans la fenêtre Boîte à Outils. Plus de 600 articles détaillés sur le développement de stratégies de trading en MQL5 sont maintenant disponibles directement dans le terminal. De nouveaux articles sont publiés chaque semaine.
   

   
   
   

   
   
5. Ajout du support de l'authentification étendue grâce aux certificats lors de l'utilisation de Wine.
   
6. Correction de l'affichage du market depth lorsqu'il est limité à un seul niveau.
7. Ajout de la commande "Sauvegarder Comme Image" dans la barre d'outils Standard. Il est maintenant beaucoup plus facile de prendre des images des graphiques et de les partager avec la communauté.
   

   
   
   

   
   
8. Correction de l'application du décalage du temps lors de l'import des barres et des ticks. Auparavant, le décalage n'était pas appliqué dans tous les cas.

   
   
   

   
   
9. Correction du gel du terminal en case de grande quantité de nouvelles du calendrier économique.

MQL5

1. Ajout du support natif pour les bibliothèques .NET avec import "intelligent" des fonctions. Les bibliothèques .NET peuvent maintenant être utilisées sans écrire de wrappers spéciaux — MetaEditor s'en occupe.
   
   Pour utiliser les fonctions des bibliothèques .NET, importez simplement la DLL sans définir de fonctions spécifiques. MetaEditor importe automatiquement toutes les fonctions utilisables :
   
   • Structures simples (POD, plain old data) — structures qui ne contiennent que des types de données simples.
   • Fonctions statiques publiques ayant des paramètres, dans lesquelles seuls des types simples et des structures POD, ou leurs tableaux, sont utilisés.
     
   
   Pour appeler des fonctions de la bibliothèque, il suffit de l'importer :
   

   #import "TestLib.dll"
   
   //+------------------------------------------------------------------+
   //| Fonction de lancement du programme                               |
   //+------------------------------------------------------------------+
   void OnStart()
     {
      int x=41;
      TestClass::Inc(x);
      Print(x);
     }

   Le code C# de la fonction Inc de TestClass ressemble à :
   

   public class TestClass
   {
      public static void Inc(ref int x)
      {
       x++;
      }
   }

   Le script retourne la valeur 42 comme résultat de l'exécution.
   
   Le travail sur le support des bibliothèques .NET continue. Leurs fonctionnalités seront étendues dans le futur.
   
   
2. Ajout du support pour l'utilisation des fonctions WinAPI de la Bibliothèque Standard. Il n'est maintenant plus nécesaire d'importer les bibliothèques manuellement et de décrire les signatures des fonctions pour utiliser les fonctions du système d'exploitation dans un programme MQL5. Incluez simplement le fichier d'en-tête depuis le répertoire MQL5\Include\WinAPI.
   
   Les fonctions WinAPI sont regroupées dans des fichiers séparés suivant leur utilisation :
   
   
   • libloaderapi.mqh — utilisation des ressources
     
   • memoryapi.mqh — utilisation de la mémoire
   • processenv.mqh — utilisation de l'environnement
     
   • processthreadsapi.mqh — utilisation des processes
     
   • securitybaseapi.mqh — utilisation du système de sécurité du système d'exploitation
     
   • sysinfoapi.mqh — obtention d'informations du système
   • winbase.mqh — fonctions communes
     
   • windef.mqh — constantes, structures et énumérations
   • wingdi.mqh — utilisation des objets graphiques
     
   • winnt.mqh — utilisation des exceptions
     
   • winreg.mqh — utilisation du registre
     
   • winuser.mqh — utilisation des fenêtres et des interfaces
     
   • errhandlingapi.mqh — gestion des erreurs
     
   • fileapi.mqh — utilisation des fichiers
     
   • handleapi.mqh — utilisation des handles
     
   • winapi.mqh — pour inclure toutes les fonctions (fichiers en-tête WinAPI)
     
   
   Le lien ne fonctionne que sur les architectures 64 bits.
   
   
3. Ajout du support des spécificateurs inline, __inline et __forceinline lors du parsing du code. La présence des spécificateurs dans le code ne cause aucune erreur et n'affecte pas la compilation. Pour l'instant, cette fonctionnalité simplifie le transfert de code C++ en MQL5.
   Obtenez plus d'informations sur les spécificateurs dans MSDN.
   
   
4. Optimisation significative de l'exécution des programmes MQL5. Dans certains cas, l'amélioration des performances peut atteindre 10%. Recompilez vos programmes avec la nouvelle version de MetaEditor pour les rendre plus rapides.
   
   Malheureusement, les nouveaux programmes ne seront plus compatibles avec les versions précédentes du terminal en raison de cette nouvelle optimisation. Les programmes compilés avec MetaEditor version 1912 et supérieurs ne peuvent pas être lancés dans les terminaux de version inférieure à 1912. Les programmes compilés dans les versions précédentes de MetaEditor fonctionnent dans les nouveaux terminaux.
   
   
   
5. Optimisation significative de plusieurs fonctions MQL5.
6. Ajout de nouvelles propriétés pour attacher/détacher des graphiques de la fenêtre principale du terminal et pour gérer leur position.
   
   Ajout des propriétés suivantes dans l'énumération ENUM_CHART_PROPERTY_INTEGER :
   
   
   • CHART_IS_DOCKED — la fenêtre du graphique est ancrée. Si elle est mise à 'false', le graphique peut être déplacé en dehors de la zone du terminal.
   • CHART_FLOAT_LEFT — la coordonnée gauche de la fenêtre détachée du graphique relativement à l'écran virtuel.
     
   • CHART_FLOAT_TOP — la coordonnée supérieure de la fenêtre détachée du graphique relativement à l'écran virtuel.
   • CHART_FLOAT_RIGHT — la coordonnée droite de la fenêtre détachée du graphique relativement à l'écran virtuel.
   • CHART_FLOAT_BOTTOM — la coordonnée inférieure de la fenêtre détachée du graphique relativement à l'écran virtuel.
   
   Ajout des fonctions suivantes dans l'énumération ENUM_TERMINAL_INFO_INTEGER :
   
   
   • TERMINAL_SCREEN_LEFT — la coordonnée gauche de l'écran virtuel. Un écran virtuel est un rectangle couvrant tous les écrans. Si le système a 2 écrans ordonnés de droite à gauche, alors la coordonnée gauche de l'écran virtuel peut être sur la bordure des 2 écrans.
   • TERMINAL_SCREEN_TOP — la coordonnée supérieure de l'écran virtuel.
   • TERMINAL_SCREEN_WIDTH — la largeur du terminal.
   • TERMINAL_SCREEN_HEIGHT — la hauteur du terminal.
   • TERMINAL_LEFT — la coordonnée gauche du terminal relativement à l'écran virtuel.
   • TERMINAL_TOP — la coordonnée supérieure du terminal relativement à l'écran virtuel.
   • TERMINAL_RIGHT — la coordonnée droite du terminal relativement à l'écran virtuel.
   • TERMINAL_BOTTOM — la coordonnée inférieure du terminal relativement à l'écran virtuel.
   
   
7. Ajout du champ volume_real dans les structures MqlTick et MqlBookInfo. Il est conçu pour utiliser les volumes avec une précision étendue. La valeur volume_real a une priorité supérieure à 'volume'. Le serveur utilisera cette valeur si elle est spécifiée.
   

   struct MqlTick
     {
      datetime         time;            // Heure de mise à jour du prix Last
      double           bid;             // Prix Bid actuel
      double           ask;             // Prix Ask actuel
      double           last;            // Prix actuel de la dernière transaction
      ulong            volume;          // Volume du prix Last actuel
      long             time_msc;        // Heure de mise à jour du prix Last en millisecondes
      uint             flags;           // Flags du tick
      double           volume_real;     // Volume du prix Last actuel avec une précision étendue
     };

   struct MqlBookInfo
     {
      ENUM_BOOK_TYPE   type;            // type d'ordre de l'énumération ENUM_BOOK_TYPE
      double           price;           // prix
      long             volume;          // volume
      double           volume_real;     // volume avec précision étendue
     };

   
   
8. Ajout de nouvelles propriétés à l'énumération ENUM_SYMBOL_INFO_DOUBLE :
   
   
   • SYMBOL_VOLUME_REAL — le volume de la dernière transaction exécutée ;
     
   • SYMBOL_VOLUMEHIGH_REAL — le plus grand volume de transaction du jour courant ;
     
   • SYMBOL_VOLUMELOW_REAL — le plus petit volume de transaction du jour courant.
     
   
   Utilisez la fonction SymbolInfoDouble pour récupérer ces propriétés.
   
   
9. Ajout de la propriété MQL_FORWARD à l'énumération ENUM_MQL_INFO_INTEGER — flag du mode de test avancé.
10. Ajout de la propriété pack( valeur_entière ) pour les structures. Elle vous permet de définir l'alignement dans l'arrangement des champs dans une structure, ce qui peut être nécessaire lors de l'utilisation de DLL. Les valeurs 1, 2, 4, 8 et 16 sont possible pour le champ valeur_entière.
    Si la propriété n'est pas définie, l'alignement par défaut de 1 octet est utilisé — pack(1).
    
    Exemple d'utilisation :
    

    //+------------------------------------------------------------------+
    //| Alignement par défaut                                            |
    //+------------------------------------------------------------------+
    struct A
      {
       char              a;
       int               b;
      };
    //+------------------------------------------------------------------+
    //| Alignement spécifié                                              |
    //+------------------------------------------------------------------+
    struct B pack(4)
      {
       char              a;
       int               b;
      };
    //+------------------------------------------------------------------+
    //| Fonction de lancement du programme                               |
    //+------------------------------------------------------------------+
    void OnStart()
      {
       Print("sizeof(A)=",sizeof(A));
       Print("sizeof(B)=",sizeof(B));
      }
    //+------------------------------------------------------------------+

    Conclusion :
    

    sizeof(A)=5
    sizeof(B)=8

    Obtenez plus d'informations sur l'alignement dans les structures dans MSDN.
    
    
11. Assouplissement des exigences pour le cast des énumérations. Dans le cas d'un casting implicite, le compilateur substitue automatiquement la valeur de l'énumération correcte et affiche un avertissement.
    
    Pour le code suivant :
    

    enum Main
      {
       PRICE_CLOSE_,
       PRICE_OPEN_
      };
    
    input Main Inp=PRICE_CLOSE;
    //+------------------------------------------------------------------+
    //| Fonction de lancement                                            |
    //+------------------------------------------------------------------+
    void OnStart()
      {
      }

    Le compilateur affiche l'avertissement suivant :
    
    implicit conversion from 'enum ENUM_APPLIED_PRICE' to 'enum Main'
    'Main::PRICE_OPEN_' instead of 'ENUM_APPLIED_PRICE::PRICE_CLOSE' will be used
    Auparavant, l'erreur suivante était générée dans ce cas :
    
    'PRICE_CLOSE' - cannot convert enum
    Le compilateur affichera toujours l'erreur si les énumérations ne sont pas utilisées correctement dans les paramètres d'une fonction.
    
    
12. Correction de la compilation des templates de fonctions. Maintenant, lors de l'utilisation de templates de fonctions surchargés, seule la surcharge nécessaire sera instanciée, au lieu de toutes les surcharges existantes.
    

    class X {  };
    
    void f(int)  {  }
      
    template<typename T>
    void a(T*) { new T(2); }  // le compilateur générait l'erreur ici auparavant
      
    template<typename T>
    void a()  { f(0); }
      
      
    void OnInit()  { a<X>(); }  

    
    
13. Optimisation de certains cas d'accès à l'historique des tick avec les fonctions CopyTicks*.
14. Ajout de la nouvelle fonction TesterStop permettant une fin prématurée d'une passe de test/d'optimisation. Lorsqu'elle est appelée, les statistiques complètes du trading et le résultat de OnTester sont passés au terminal client, comme lors d'une fin normale d'un test ou d'une optimisation.
    
15. Ajout de la nouvelle propriété #property tester_everytick_calculate pour les indicateurs personnalisés. Elle est utilisée dans le strategy tester et permet de forcer le calcul de l'indicateur à chaque tick.
    

Tester

1. Maintenant, dans le cas d'un test ou d'une optimisation non visuelle, tous les indicateurs utilisés (standards et personnalisés) ne sont calculés que lors d'une demande de données. Seuls les indicateurs contenant des appels à la fonction EventChartCustom et appliquant la fonction OnTimer restent inchangés. Auparavant, tous les indicateurs étaient calculés sans condition dans le strategy tester à chaque tick entrant (même pour d'autres instruments). La nouvelle fonctionnalité accélère de façon significative le test et l'optimisation.
   
   Pour activer le calcul forcé de l'indicateur à chaque tick, ajoutez la propriété #property tester_everytick_calculate pour le programme.
   Les indicateurs compilés avec les versions précédentes du compilateur restent calculé comme avant — à chaque tick.
   
   
2. Correction du calcul de la précision de la devise du dépôt lors d'un test/d'une optimisation et lors de la génération des rapports correspondants.
3. Optimisation et accélèration du fonctionnement du strategy tester.
4. Correction de quelques erreurs de test et d'optimisation.
   

MetaEditor

1. Correction de la recherche sur mots entiers. L'underscore est maintenant considéré comme un caractère normal plutôt que comme délimiteur de mot lors d'une recherche.
   

Mise à jour de la documentation.

Terminal

1. La recherche des symboles de trading par ISIN (International Securities Identification Number) a été ajoutée dans la fenêtre du Market Watch. Vous pouvez maintenant ajouter des symboles de 3 façons : par nom, description et ISIN.

   
   
   

   
   
2. Correction du ralentissement de l'interface utilisateur lors du changement du mot de passe du compte de trading.
3. Correction de l'augmentation de charge occasionnelle du CPU causée par le terminal client.

1. Correction du passage d'en-tête HTTP personnalisés dans la fonction WebRequest.
2. Correction du comportement de la fonction Bars dans les cas où les dates de début et de fin de l'intervalle sont les mêmes. S'il y a une barre, la fonction retourne maintenant 1. Dans les versions précédentes, la fonction retournait 0 de façon inconditionnelle.

1. Correction du lancement d'un test en mode visuel après une optimisation avancée.
2. Correction du tri des résultats d'optimisation. Le tri prend maintenant en compte les passes avec des paramètres d'entrée incorrects (INIT_INCORRECT_PARAMETERS) et celles n'ayant pas de facteur de profit.
3. Correction du recalcul du graphique de l'optimisation génétique après le changement du critère d'optimisation.
   

La documentation a été mise à jour.

Terminal

1. La boîte de dialogue d'ouverture de compte a été complétement repensée. Vous pouvez maintenant sélectionner un courtier dans la liste et ensuite choisir le type de compte désiré. Cette mise à jour permet de réduire la liste des courtiers, puisqu'elle ne contient maintenant que les noms des sociétés au lieu de tous les serveurs disponibles.
   
   Les logos des compagnies sont également affichés dans la liste pour rendre la recherche plus facile et plus efficace. Si le courtier désiré n'apparaît pas dans la liste, tapez le nom de la société ou l'adresse du serveur dans la barre de recherche et cliquez sur "Trouver votre courtier".
   

   
   
   

   
   Les descriptions des types de comptes ont été ajoutées dans la boîte de dialogue pour aider les débutants à choisir le bon compte. Pour être alignés avec le General Data Protection Regulation (GDPR), la nouvelle boîte de dialogue peut contenir des liens vers leurs accords et politiques de protection des données :
   

   
   
   

   
   Les possibilités d'ouverture de comptes réels ont été étendues de façon significative. La fonctionnalité de chargement des documents de confirmation de l'identité et de l'adresse, qui était auparavant disponible dans les terminaux mobiles, est maintenant disponible dans la version de bureau. Désormais, les courtiers réglementés MiFID peuvent demander toutes les données d'identification de client requises, y compris des informations sur l'emploi, le revenu, l'expérience de trading, etc. La nouvelle fonctionnalité aidera les traders à ouvrir des comptes réels plus rapidement et plus facilement, sans procédure bureaucratique inutile.

   
   
   

2. L'historique des transactions affiche maintenant les valeurs du Stop Loss et du Take Profit. Les valeurs des Stop Loss et Take Profit pour les transactions d'entrée et de renversement sont définies selon les Stop Loss et Take Profit des ordres qui ont initiés ces transactions. Les valeurs du Stop Loss et du Take Profit des positions correspondantes au moment de la clôture de la position sont utilisées pour les transactions de sortie. Ces dernières permettent d'enregistrer et de montrer les informations des Stop Loss et Take Profit d'une position au moment de sa fermeture. Cette information n'était pas stockée dans les versions antérieures, puisque les positions disparaissent après la fermeture, tandis que l'historique des positions dans le terminal est généré en fonction des transactions.
   

   
   
   

   
   
3. L'historique des positions affiche maintenant les valeurs du Stop Loss et du Take Profit. Les valeurs des Stop Loss et Take Profit des transactions qui ont ouvert et fermer les positions correspondantes sont spécifiées pour ces positions.

   
   
   

   
   
4. Le volume actuel des ordres en attente est maintenant affiché sur le graphique au lieu du volume demandé initialement.

   
   

   
   
5. Le terminal mis à jour offre un rendu optimisé et plus rapide de la fonction Market Depth en mode étendu avec l'affichage du spread activé.
6. Le traitement des résultats d'exécution d'une demande de trade a été optimisé. Cette optimisation permet un traitement bien plus rapide dans certains cas.
7. Correction d'une erreur dans l'opération Trailing Stop, qui pouvait occasionnellement entraîner l'envoi de plusieurs demandes de modification du Stop Loss pour la même position..
8. Correction du réglage du volume minimum et maximum, ainsi que du pas de volume dans les paramètres des symboles personnalisés.
9. Correction d'une erreur, à cause de laquelle l'option "Echelle Fixe" pouvait être ignorée, lors de l'application d'un template au graphique du symbole.
10. Correction d'une accumulation incorrecte occasionnelle de l'historique des ticks.

MQL5

1. La vitesse d'exécution des applications MQL5 a été améliorée grâce à une optimisation supplémentaire du code source pendant la compilation. Recompilez vos programmes avec la nouvelle version de MetaEditor pour les faire s'exécuter plus rapidement.
   
   Malheureusement, les nouveaux programmes ne seront pas compatibles avec les précédentes versions du terminal en raison de cette optimisation supplémentaire. Les programmes compilés dans MetaEditor version 1855 et supérieur ne peuvent pas être lancés dans les terminaux des versions inférieures à 1855. Les programmes compilés dans les versions précédentes de MetaEditor peuvent s'exécuter sur les nouveaux terminaux.
   
   
   
2. Nouvelles fonctions : iTime, iOpen, iHigh, iLow, iClose, iVolume, iBars, iBarShift, iLowest, iHighest, iRealVolume, iTickVolume, iSpread. Ces fonctions sont similaires à celles utilisées en MQL4. Les fonctions permettent un transfert plus facile du code des applications de trading vers la plateforme de 5ème génération.
   
   Auparavant, la plupart des tâches effectuées avec ces fonctions pouvaient être implémentées avec les fonctions Copy*. Cependant, les utilisateurs devaient implémenter leurs propres fonctions pour trouver les valeurs High/Low sur le graphique et pour rechercher les barres suivant leur date et heure. Maintenant, ces tâches peuvent être exécutées facilement avec les fonctions iHighest, iLowest et iBarShift.
   
   iTime
   Retourne l'heure d'ouverture (Open) de la barre (indiquée par le paramètre 'shift') sur le graphique correspondant.
   

   datetime  iTime(
      string           symbol,          // Symbole
      ENUM_TIMEFRAMES  timeframe,       // Période
      int              shift            // Décalage
      );

   
   iOpen
   Retourne le prix d'ouverture (Open) de la barre (indiquée par le paramètre 'shift') sur le graphique correspondant.
   

   double  iOpen(
      string           symbol,          // Symbole
      ENUM_TIMEFRAMES  timeframe,       // Période
      int              shift            // Décalage
      );

   
   iHigh
   Retourne le prix High de la barre (indiquée par le paramètre 'shift') sur le graphique correspondant.
   

   double  iHigh(
      string           symbol,          // Symbole
      ENUM_TIMEFRAMES  timeframe,       // Période
      int              shift            // Décalage
      );

   
   iLow
   Retourne le prix Low de la barre (indiquée par le paramètre 'shift') sur le graphique correspondant.
   

   double  iLow(
      string           symbol,          // Symbole
      ENUM_TIMEFRAMES  timeframe,       // Période
      int              shift            // Décalage
      );

   
   iClose
   Retourne le prix de clôture (Close) de la barre (indiquée par le paramètre 'shift') sur le graphique correspondant.
   

   double  iClose(
      string           symbol,          // Symbole
      ENUM_TIMEFRAMES  timeframe,       // Période
      int              shift            // Décalage
      );

   
   iVolume
   Retourne le volume des ticks de la barre (indiquée par le paramètre 'shift') sur le graphique correspondant.
   

   long  iVolume(
      string           symbol,          // Symbole
      ENUM_TIMEFRAMES  timeframe,       // Période
      int              shift            // Décalage
      );

   
   iBars
   Retourne le nombre de barres du symbole et de la période correspondants, disponible dans l'historique.
   

   int  iBars(
      string           symbol,          // Symbole
      ENUM_TIMEFRAMES  timeframe        // Période
      );

   
   iBarShift
   Recherche une barre par la date/heure. La fonction retourne l'indice de la barre correspondant à la date/heure spécifiée.
   

   int  iBarShift(
      string           symbol,          // Symbole
      ENUM_TIMEFRAMES  timeframe,       // Période
      datetime         time,            // Heure
      bool             exact=false      // Mode
      );

   
   iLowest
   Retourne l'indice de la plus petite valeur trouvée sur le graphique correspondant (décalage relatif à la barre courante).
   

   int  iLowest(
      string           symbol,          // Symbole
      ENUM_TIMEFRAMES  timeframe,       // Période
      int              type,            // Identifiant de la timeserie
      int              count,           // Nombre d'éléments
      int              start            // Indice
     );

   
   iHighest
   Retourne l'indice de la plus grande valeur trouvée sur le graphique correspondant (décalage relatif à la barre courante).
   

   int  iHighest(
      string           symbol,          // Symbole
      ENUM_TIMEFRAMES  timeframe,       // Période
      int              type,            // Identifiant de la timeserie
      int              count,           // Nombre d'éléments
      int              start            // Indice
     );

   
   iRealVolume
   Retourne le volume réel de la barre (indiquée par le paramètre 'shift') sur le graphique correspondant.
   

   long  iRealVolume(
      string           symbol,          // Symbole
      ENUM_TIMEFRAMES  timeframe,       // Période
      int              shift            // Décalage
      );

   
   iTickVolume
   Retourne le volume des ticks de la barre (indiquée par le paramètre 'shift') sur le graphique correspondant.
   

   long  iTickVolume(
      string           symbol,          // Symbole
      ENUM_TIMEFRAMES  timeframe,       // Période
      int              shift            // Décalage
      );

   
   iSpread
   Retourne la valeur du spread de la barre (indiquée par le paramètre 'shift') sur le graphique correspondant.
   

   long  iSpread(
      string           symbol,          // Symbole
      ENUM_TIMEFRAMES  timeframe,       // Période
      int              shift            // Décalage
      );

3. Ajout de la nouvelle fonction TesterHideIndicators. La fonction définit le mode Afficher/Masquer pour les indicateurs utilisés dans les Expert Advisors. La fonction permet de gérer la visibilité des indicateurs utilisés uniquement pendant les tests. Définissez-le à true si vous souhaitez cacher les indicateurs créés. Sinon définissez-le à false.
   

   void  TesterHideIndicators(
      bool      hide     // Flag
      );

4. Ajout de la génération de l'évènement CHARTEVENT_CLICK lors du clic sur les niveaux de trade sur le graphique.
   
5. Correction et optimisation de l'utilisation des fonctions CopyTicks.
   
6. Correction de la valeur retournée par la fonction SymbolInfoDouble pour la propriété SYMBOL_TRADE_LIQUIDITY_RATE.
   
7. Correction de la copie de tableaux de chaînes de caractères avec une mémoire qui se chevauche.
8. Correction de l'allocation d'un tableau de chaîne de caractères dans la fonction FileReadArray.
9. Correction d'erreurs dans la Bibliothèque Standard MQL5.

Tester

1. Le système d'utilisation du cache d'optimisation a été mis à jour. Le cache stocke les données des passes d'optimisation calculées auparavant. Le testeur de stratégies stocke les données pour permettre de reprendre l'optimisation après une pause et d'éviter le recalcul des passes de test déjà effectuées.
   
   Changements dans le format de stockage du cache d'optimisation
   Dans les versions précédentes, le cache d'optimisation était stocké comme un seul fichier XML. Toutes les passes d'optimisation d'un Expert Advisor avec les paramètres de test spécifiés étaient ajoutées à ce fichier. Le même fichier sotckait donc les résultats d'optimisations avec différents paramètres d'entrée dans le même fichier.
   Le cache d'optimisation est maintenant stocké sous forme de fichiers binaires pour chaque ensemble de paramètres optimisés. Les opérations du Strategy Tester impliquant le cache d'optimisation sont devenues significativement plus rapides grâce au nouveau format et à la taille réduite du fichier. L'accélération peut être particulièrement visible lorsque vous reprenez une passe d'optimisation en pause.
   
   Affichage des résultats des optimisations précédentes
   Les résultats des optimisations précédentes peuvent maintenant être visualisés directement dans le Strategy Tester. Il n'est donc pas nécessaire d'analyser des fichiers XML volumineux en utilisant un logiciel tiers. Ouvrez l'onglet "Résultats d'optimisation", sélectionnez un Expert Advisor et un fichier avec le cache d'optimisation :
   
   

   
   

   La liste contient tous les fichiers de cache d'optimisation existants sur le disque pour l'Expert Advisor sélectionné. La date d'optimisation, les paramètres de test (symbole, période, intervalle) et les paramètres d'entrée sont affichés pour chaque fichier. Vous pouvez aussi filtrer les résultats d'optimisation par le serveur de trading sur lequel les résultats ont été obtenus.
   
   Recalcul du critère d'optimisation à la volée
   Un critère d'optimisation est un certain paramètre variable dont la valeur détermine la qualité d'un ensemble d'entrées testé. Plus la valeur du critère d'optimisation est élevée, meilleur est le résultat du test avec l'ensemble de paramètres donné.
   
   Auparavant, un seul critère sélectionné avant le démarrage de l'optimisation était calculé lors de l'optimisation. Vous pouvez maintenant modifier le critère d'optimisation à la volée lors de la visualisation des résultats, et le Strategy Tester recalculera automatiquement toutes les valeurs.
   

   
   
   

   
   Utilisation manuelle du cache d'optimisation
   Dans les versions antérieures, le cache d'optimisation était stocké sous la forme d'un fichier XML, qui pouvait être ouvert et analysé à l'aide d'un logiciel tiers. Il est maintenant stocké sous forme de fichiers binaires. Pour obtenir des données au format XML, exportez-les en utilisant le menu contextuel de l'onglet "Résultats d'optimisation".
   
   
2. Ajout de la possibilité de définir manuellement la devise du dépôt et le levier pour le test et l'optimisation. Dans les versions précédentes, la devise était définie selon le compte connecté. Il fallait donc changer de compte pour changer la devise. La taille de levier ne peut être sélectionnée qu'à partir d'une liste prédéfinie, maintenant il est possible de spécifier n'importe quelle valeur.
   
   Veuillez noter que des taux croisés pour la conversion du profit et de la marge dans la devise du dépôt spécifiée doivent être disponibles sur le compte, afin de garantir des tests appropriés.
   

   
   
   

   
   
3. Suppression de l'interdiction d'utiliser OpenCL dans les agents de test. Auparavant, les périphériques OpenCL n'étaient autorisés que lors de tests sur les agents locaux. Désormais, les agents sont autorisés à utiliser tous les périphériques OpenCL disponibles (tels que le processeur, la carte vidéo) lorsqu'ils travaillent sur le réseau local.et dans le MQL5 Cloud Network.

MetaEditor

1. Utilisation optimisée et accélétée du MQL5 Storage.
   
2. Correction de la reprise du processus de débogage après une pause dans le fichier MQH.
   
3. Correction de la mise en surbrillance du code source dans l'éditeur.
4. Correction de la navigation dans les résultats de recherche.
5. Correction de la fonction de remplacement massif de texte. Dans certains cas, seules les premières occurrences étaient remplacées.
   

La documentation a été mise à jour.

Terminal

1. Correction d'une erreur du terminal et de MetaEditor qui empêchait la fermeture et le redémarrage de Windows.
   
2. Correction du décalage du graphique lors de l'utilisation d'un modèle.

MQL5

1. Correction d'erreurs qui ralentissaient la compilation dans certaines conditions.

Correction d'erreurs reportées dans les journaux de crash.

MetaTrader 5 build 1745 sera la dernière version de la plateforme supportant Microsoft Windows XP/2003/Vista.

Nous avons annoncé il y a quelques mois la prochaine fin du support des anciennes versions des systèmes d'exploitation. Windows 2003, Windows Vista et spécialement Microsoft Windows XP sont des systèmes d'exploitation dépassés. Microsoft a mis fin au support de Windows XP il y a 3 ans, car des possibilités matérielles potentielles ne pouvaient plus être réalisées sur ce système en raison de limitations techniques.

MetaTrader 5 build 1745 et les versions précédentes continueront de fonctionner sur les systèmes d'exploitations mentionnés ci-dessus, mais ne seront plus mis à jour. Les installateurs ne s'exécuteront pas non plus sur ces systèmes d'exploitation.

Le système d'exploitation minimum requis pour faire fonctionner MetaTrader 5 est Windows 7. Nous recommandons cependant fortement d'utiliser les versions 64 bits de Windows 10.

Terminal

1. L'option /auto a été ajoutée à l'installateur, permettant d'installer le programme en mode automatisé sans action supplémentaire requise de la part de l'utilisateur. Lorsque l'installateur est lancé avec cette option, les paramètres d'installation ne sont pas montrés à l'utilisateur, et le terminal est installé à l'endroit par défaut et avec le nom de dossier standard pour le menu Démarrer pour le programme. Exemple de lancement :
   
   C:\mt5setup.exe /auto
   
2. Correction de l'utilisation de l'installateur dans les cas où l'utilisateur du système n'a pas les bons droits.
3. Correction de la consommation excessive de ressources CPU lorsqu'aucune action n'est effectuée dans le terminal (lorsqu'il n'y a aucun graphique ouvert et qu'aucune action n'est effectuée par l'utilisateur).
   
4. La nouvelle version contient la compression automatique des fichiers *.log au niveau du système de fichiers. La nouvelle fonctionnalité permet de réduire la quantité d'espace disque utilisée par les journaux.
   

Tester

1. La quantité de cache pendant l'exécution de tests simples a été augmentée. Cela permet d'avoir des tests plus rapides sur les systèmes 64 bits.
   
2. Correction de l'optimisation des robots de trading via le MQL5 Cloud Network. Des problèmes pouvaient survenir avec les produits achetés sur le MetaTrader Market.
3. Correction du calcul des spreads des barres générées dans le mode de test "Chaque Tick".
4. Correction de la sélection du périphérique OpenCL dans le strategy tester. Le tester visuel peut maintenant accéder à tous les périphériques OpenCL disponibles.
5. La nouvelle version comporte la compression automatique des fichiers *.log au niveau du système de fichiers. La nouvelle fonctionnalité permet de réduire la quantité d'espace disque utilisée par les journaux.

MQL5

1. Correction de la suppression des barres d'un symbole personnalisé avec la méthode CustomRatesDelete.

Fin du Support des Anciennes Versions du Terminal

Le support des anciennes versions des terminaux de bureau et mobile prendre fin avec la publication de la nouvelle version de la plateforme :

• Terminal Client : versions inférieures à 730, du 23 novembre 2012
• Terminal Mobile pour iPhone : versions inférieures à 1171, du 11 novembre 2015
• Terminal Mobile pour Android : versions inférieures à 1334, du 5 août 2016

Les versions non supportées du terminal ne pourront plus se connecter aux nouvelles versions du serveur. Nous vous recommandons fortement de mettre à jour vos terminaux en avance.

Changements du Protocoles des Opérations du MQL5 Storage

Pour supporter les nouveaux projets partagés, nous avons mis à jour le protocole des opérations du MQL5 Storage. Vous devrez donc effectuer un checkout de toutes les données du dépôt après la mise à jour de la plateforme. Les données stockées sur le MQL5 Storage ne seront pas perdues ou modifiées pendant la mise à jour.

Avant de mettre à jour la plateforme vers la nouvelle version, nous vous recommandons d'effectuer une opération de Commit pour envoyer tous les changements locaux vers le MQL5 Storage.

Terminal

1. La plateforme de trading permet maintenant de créer des instruments financier synthétiques, c'est à dire des symboles basés sur un ou plusieurs instruments existants. L'utilisateur doit définir la formule pour le calcul des cotations, après laquelle la plateforme génèrera les ticks de l'instrument synthétique en temps réel et créera aussi son historique en minutes.
   
   

   Comment Cela Fonctionne

   • Vous créez un instrument synthétique et définissez la formule de calcul du prix.
   • La plateforme calcule les ticks à une fréquence de 10 fois par seconde, pourvu que le prix d'au moins l'un des instruments utilisés dans la formule a changé.
   • La plateforme calcule aussi l'historique des barres 1-minute (pour les deux derniers mois) basées sur les barres minute des instruments utilisés dans sa formule. Toutes les nouvelles barres (la courante et les suivantes) sont construites en temps réel sur la base des ticks générés de l'instrument synthétique.
     

   Par exemple, vous pouvez créer un instrument affichant l'indice du dollar (USDX). Il utilise la formule suivante :

   50.14348112 * pow(ask(EURUSD),-0.576) * pow(USDJPY,0.136) * pow(ask(GBPUSD),-0.119) * pow(USDCAD,0.091) * pow(USDSEK,0.042) * pow(USDCHF,0.036)

   Note : les paires USDEUR et USDGBP sont utilisées dans la formule source de l'indice du dollar. Puisque seules les paires inverses sont disponibles dans la plateforme, une puissance négatique et Ask au lieu de Bid sont utilisés dans la formule du symbole synthétique.
   
   La plateforme calculera en temps réel le prix du nouvel instrument sur la base des cotations des six autres symboles fournis par votre courtier. Les changements de prix seront visualisés dans la fenêtre du Market Watch et sur le graphique :

   
   
   
   

   Créez un nouveau symbole personnalisé, ouvrez sa spécification et entrez la formule :
   

   
   
   
   

   L'éditeur de formules affiche de façon pratique la liste des options possibles lorsque vous tapez les noms des symboles et des fonctions.
   
   Le calcul des ticks et des barres 1-minute d'un instrument synthétique commence lorsque cet instrument est ajouté au Market Watch. Tous les symboles nécessaires pour le calcul du prix synthétique sont également automatiquement ajoutés au Market Watch. Une entrée concernant le démarrage du calcul sera ajoutée dans le journal de la plateforme: Synthetic Symbol USDX: processing started.
   • Le calcul d'un instrument synthétique est stoppé lorsqu'il est enlevé du Market Watch.
   • Les symboles qui sont actuellement utilisés pour le calcul des prix du symbole synthétique ne peuvent pas être cachés dans le Market Watch.
   
   Calcul en Temps Réel des Cotations
   Toutes les 100 ms (c'est à dire 10 fois par seconde), les prix des symboles utilisés dans le calcul sont vérifiés. Si au moins l'un d'eux a changé, le prix du symbole synthétique est calculé et un nouveau tick est généré. Le calcul est effectué en parallèle dans 3 threads pour les prix Bid, Ask et Last. Par exemple, si la formule de calcul est EURUSD*GBPUSD, le prix du symbole synthétique sera calculé comme suit :
   
   
   • Bid = bid(EURUSD)*bid(GBPUSD)
   • Ask = ask(EURUSD)*ask(GBPUSD)
   • Last = last(EURUSD)*last(GBPUSD)
   
   La disponibilité des changements est vérifiée séparément pour chaque prix. Par exemple, si seul le prix Bid d'un instrument source a changé, seul le prix correspondant d'un instrument synthétique sera calculé.
   
   Création de l'Historique des Barres Minute
   En plus de collecter les ticks en temps réel, la plateforme crée un historique en minute de l'instrument synthétique. Il permet aux traders de voir les graphiques du symbole synthétique comme pour les symboles normaux, mais aussi d'effectuer des analyses techniques en utilisant des objets et des indicateurs.
   
   Lorsqu'un trader ajoute un instrument synthétique dans le Market Watch, la plateforme vérifie si son historique en minutes existe. S'il n'existe pas, l'historique des 60 derniers jours sera créé, ce qui inclut environ 50.000 barres. Si une valeur inférieure est spécifiée dans le paramètre 'Max. barres dans le graphique' des paramètres de la plateforme, la restriction correspondante sera appliquée.
   
   Si certaines barres dans cette période ont déjà été créées, la plateforme générera en plus de nouvelles barres. Un historique plus profond est créé si l'utilisateur essaye de voir une période plus ancienne sur le graphique (en le faisant défiler en arrière ou en y accédant depuis un programme MQL5).
   
   L'historique des barres 1-minute d'un instrument synthétique est calculé sur la base des barres 1-minutes (et pas des ticks) des instruments utilisés dans sa formule. Par exemple, pour calculer le prix Open d'une barre 1-minute d'un symbole synthétique, la plateforme utilise les prix Open des symboles utilisés dans sa formule. Les prix High, Low et Close sont calculés de façon similaire.
   
   Si la barre requise n'est pas disponible pour l'un des instruments, la plateforme utilisera le prix Close de la barre précédente. Par exemple, 3 instruments sont utilisés : EURUSD, USDJPY et GBPUSD. Si dans le calcul d'une barre correspondant à 12:00 la barre requise de USDJPY n'est pas disponible, les prix suivantes seront utilisés pour le calcul :
   
   
   • Open: EURUSD Open 12:00, USDJPY Close 11:59, GBPUSD Open 12:00
   • High: EURUSD High 12:00, USDJPY Close 11:59, GBPUSD High 12:00
   • Low: EURUSD Low 12:00, USDJPY Close 11:59, GBPUSD Low 12:00
   • Close: EURUSD Close 12:00, USDJPY Close 11:59, GBPUSD Close 12:00
   
   Si une barre minute n'est disponible pour aucun des instruments utilisés dans la formule, la barre minute correspondante de l'instrument synthétique ne sera pas calculée.
   
   Dessin des Nouvelles Barres Minute
   Toutes les nouvelles barres (la courante et les suivantes) de l'instrument synthétique sont créées sur la base des ticks générés. Le prix utilisé pour construire les barres dépend de la valeur du paramètre Mode du Graphique dans la spécification :
   

   
   
   
   

   
   Quelles Opérations Peut Être Utilisées dans la Formule du Symbole
   Les données des prix et certaines propriétés des symboles existants fournis par le courtier peuvent être utilisées pour calculer les prix synthétiques. Spécifiez les éléments suivants :
   
   
   • Nom du symbole — suivant le prix synthétique à calculer, le prix Bid, Ask ou Last de l'instrument spécifié sera utilisé. Par exemple, si EURUSD*GBPUSD est spécifié, le prix Bid est calculé comme bid(EURUSD)*bid(GBPUSD), et Ask = ask(EURUSD)*ask(GBPUSD).
   • bid(nom du symbole) — le prix bid du symbole spécifié sera obligatoirement utilisé pour le calcul du prix Bid de l'instrument synthétique. Cette option est similaire à la précédente (où le type du prix n'est pas spécifié).
   • ask(nom du symbole) — le prix Ask du symbole spécifié sera utilisé pour le calcul du prix Bid de l'instrument synthétique. Le prix Bid de l'instrument spécifié sera utilisé pour calculer le prix Ask. Le prix Last du symbole spécifié sera utilisé pour calculer le prix Last. Si ask(EURUSD)*GBPUSD est spécifié, le calcul suivant sera utilisé :
   • Вid = ask(EURUSD)*bid(GBPUSD)
   • Ask = bid(EURUSD)*ask(GBPUSD)
   • Last = last(EURUSD)*last(GBPUSD)
   • last(nom du symbole) — le prix Last du symbole spécifié sera utilisé dans le calcul de tous les prix de l'instrument synthétique (Bid, Ask et Last). Si last(EURUSD)*GBPUSD est spécifié, le calcul suivant sera utilisé :
   • Вid = last(EURUSD)*bid(GBPUSD)
   • Ask = last(EURUSD)*ask(GBPUSD)
   • Last = last(EURUSD)*last(GBPUSD)
   • volume(nom du symbole) — le volume du tick de l'instrument spécifié sera utilisé dans la formule. Assurez-vous que l'information du volume est fournie par le courtier pour ce symbole.
   • point(nom du symbole) — le changement minimum de prix de l'instrument spécifié sera utilisé dans les calculs.
   • digits(nom du symbole) — le nombre de décimales dans le prix du symbole spécifié qui seront utilisées dans la formule.
   
   
   Si un symbole a un nom complexe (contient des traits d'union, des points, etc.), il doit être écrit entre guillemets. Exemple : "RTS-6.17".
   
   Les opérations arithmétiques suivantes peuvent être utilisées dans la formule : addition (+), soustraction (-), multiplication (*), division (/) et modulo(%). Par exemple, EURUSD+GBPUSD signifie que le prix est calculé comme étant la somme des prix EURUSD et GBPUSD. Vous pouvez également utiliser l'opérateur unaire 'moins' pour changer le signe, par exemple : -10*EURUSD.
   
   Prenez garde à la priorité de calcul des opérations arithmétiques :
   
   
   • Les opérations de multiplication, division et modulo sont effectuées en premier ; ensuite les opérations d'addition et de soustraction sont effectuées.
   • Les opérations sont effectuées de gauche à droite. si la formule utilise plusieurs opérations ayant la même priorité (par exemple multiplication et division), l'opération la plus à gauche sera effectuée en premier.
   • Vous pouvez utiliser des parenthèses ( et ) pour changer la priorité des opérations. Les opérations entre parenthèses ont la plus haute priorité dans le calcul. Le principe gauche-vers-droite s'applique également pour elles : les opérations entre parenthèses les plus à gauche sont calculées en premier.
   
   Vous pouvez utilisez des constantes dans la formule :
   
   
   • Numérique (integer et float). Exemple : EURUSD*2+GBPUSD*0.7.
   • Les propriétés _Digits et _Point du symbole. Elles ajoutent les propriétés correspondantes de la spécification du symbole personnalisé à sa formule. _Digits signifie le nombre de décimales dans le prix de l'instrument ; _Point signifie le plus petit changement dans le prix du symbole.
   
   Vous pouvez également utiliser dans la formule toutes les fonctiosn mathématiques supportées en MQL5, excepté les fonctions MathSrand, MathRand et MathIsValidNuber : seuls les noms courts sont utilisés pour toutes les fonctions, tels que fabs(), acos(), asin() etc.
   
   
2. Une nouvelle option a été implémentée, permettant d'ajouter des cotations des instruments personnalisés en temps réel. Il est maintenant possible de développer un Expert Advisor MQL5 qui fournirait les cotations du symbole personnalisé spécifié. La fonction CustomTicksAdd est utilisée pour cela.
   

   int  CustomTicksAdd(
      const string           symbol,       // Nom du symbole
      const MqlTick&         ticks[]       // Le tableau contenant les ticks devant être appliqués au symbole personnalisé
      );

   La fonction CustomTicksAdd permet de fournir les cotations comme si elles étaient reçues du serveur du courtier. Les données sont envoyées dans la fenêtre du Market Watch au lieu d'être directement écrites dans la base de données des ticks. Le terminal sauvegarde ensuite les ticks depuis le Market Watch vers la base de données. Si un gros volume de données est passé dans un appel, le comportement de la fonction est adapté afin d'économiser des ressources. Si plus de 256 ticks sont transmis, les données sont divisées en 2 parties. Une grande partie est directement enregistrée dans la base de données des ticks (de façon similaire à CustomTicksReplace). La seconde partie correspondant aux 128 derniers ticks est envoyée au Market Watch, d'où le terminal sauvegarde les ticks dans une base de données.
   
   
3. La fenêtre du Market Watch présente maintenant en plus les prix High et Low. Ces colonnes sont cachées par défaut. Elles peuvent être activées en utilisant le menu contextuel :
   

   
   
   

   
   Si le graphique d'un symbole est construit en utilisant les prix bid (comme spécifié dans les paramètres), les prix Bid High et Bid Low sont affichés pour ce symbole. Si le graphique d'un symbole est construit en utilisant les prix Last, les prix Last High et Last Low sont affichés pour ce symbole.
   
   Si le Market Watch contient au moins un symbole dont le graphique est dessiné sur la base des prix Last, la colonne Last est automatiquement activée en plus de High/Low.
   
   
4. Il est maintenant possible d'éditer l'historique des ticks des intruments financiers personnalisés. Cliquez sur 'Symboles' dans le menu contextuel du Market Watch, sélectionnez un symbole personnalisé et demandez l'intervalle de données désiré dans l'onglet Ticks.
   
   
   • Double-cliquez pour changer la valeur.
   • Utilisez le menu contextuel pour ajouter ou supprimer des entrées.
   • Si vous devez supprimer plusieurs barres/ticks en une seule fois, sélectionnez-les avec la souris, en utilisant les touches Shift ou Ctrl+Shift.
     
   
   

   
   

   Pour plus de commodités, les entrées modifiées sont surlignées comme suit :
   
   
   • Un fonds vert indique une entrée modifiée
   • Un fonds gris indique une entrée supprimée
   • Un fonds jaune indique une entrée ajoutée
   
   Pour sauvegarder les changements, cliquez sur "Appliquer les Changements" en bas de la fenêtre.
   
   
5. Ajout de l'affichage des comptes préliminaires dans l'arbre du Navigateur.
   
   Les traders peuvent demander à un courtier d'ouvrir un compte réel directement depuis les terminaux de bureau. L'utilisateur doit remplir un simple formulaire avec les détails pour être contacté. Un compte préliminaire spécial est ensuite créé pour le trader. Le courtier contacte ensuite le trader pour formaliser la relation et activer le compte réel depuis le compte préliminaire.
   
   

   
   

   
   
6. Ajout de l'affichage de l'heure en millisecondes dans la fenêtre Quotes.

   
   
   
   

   
   
7. La recherche des serveurs disponibles dans la boîte de dialogue d'ouverture d'un nouveau compte est maintenant plus rapide.
8. Correction de l'affichage des objets graphiques Ligne de Tendance avec les options Prolongement vers la Gauche et Prolongement vers la Droite activées.
9. Utilisation optimisée d'un grand nombre de mails internes (centaines de milliers).
10. Utilisation du terminal optimisée avec un grand nombre d'instruments de trading (50.000 ou plus).
11. Ajout de l'optimisation de l'historique des ticks des instruments financiers personnalisés exécutée après l'édition de l'historique.
    

MetaEditor

1. Les projets complets sont maintenant disponibles dans MetaEditor. Le processus de développement d'un programme est maintenant plus pratique.
   
   Le fichier MQ5 principal du programme n'apparaît plus comme un projet. Le projet est un fichier "MQPROJ" séparé, qui stocke les paramètres du programme, les paramètres de compilation et toutes les informations des fichiers utilisés. Les principaux paramètres du projet sont accessibles depuis une boîte de dialogue séparée, il n'est donc plus besoin de les spécifier dans le code source via #property.

   Un onglet séparé dans le Navigateur est fourni pour travailler de façon plus pratique dans le projet. Tous les fichiers, tels que les fichiers include, les ressources, les headers et les autres fichiers sont ordonnés par catégories dans cet onglet. Tous les fichiers sont automatiquement ajoutés dans le navigateur du projet. Par exemple, si vous incluez un nouveau fichier MQH, il apparaîtra automatiquement dans la section "Dépendences" du navigateur.
   
   Le support des nouveaux projets a également été implémenté dans le dépôt MQL5 Storage mis à jour en ligne. Il est maintenant devenu plus pratique de développer de gros projets en collaboration avec d'autres membres de la MQL5.community.

   La nouvelle section Projets Partagés est fournie pour les projets de groupe. Un projet créé dans cette section est immédiatement envoyé dans le dépôt : vous pouvez donner des permissions à d'autres utilisateurs et démarrer votre collaboration immédiatement.

   
   
   
   

   Lorsque vous compilez un projet dans les Projets Partagés, un fichier EX5 exécutable est automatiquement copié dans le répertoire Experts, Indicators ou Scripts suivant le type du programme. Vous pouvez facilement lancer le programme sur un graphique sans avoir à copier les fichiers manuellement.

   
   Quelles sont les nouveautés dans les Opérations du MQL5 Storage

   Pour implémenter le support des nouveaux projets partagés, nous avons modifié le protocole des opérations avec le MQL5 Storage. Vous devrez donc effectuer un checkout de toutes les données du dépôt après la mise à jour de la plateforme. Les données stockées sur le dépôt MQL5 ne seront pas perdues ou modifiées pendant la mise à jour.

   Avant de mettre à jour la plateforme vers la nouvelle version, nous vous recommandons d'effectuer une opération de Commit pour envoyer tous les changements locaux vers le MQL5 Storage.
   

   La commande 'Checkout depuis le Dépôt' n'est pas disponible. Au lieu de cela, les commandes 'Activer le MQL5 Storage' et 'Mettre à Jour depuis le Storage' sont utilisées pour récupérer les données :

   • Si vous n'avez utilisé le MQL5 Storage dans l'instance actuelle de MetaEditor, cliquez sur 'Activer le MQL5 Storage' dans le menu contextuel de la fenêtre du Navigateur. Tous les catalogues et les fichiers disponibles dans le dépôt seront téléchargés sur votre ordinateur.
   • Si vous avez déjà utilisé le dépôt, cliquez sur 'Mettre à Jour les fichiers depuis le Storage' dans le menu contextuel d'un projet donné ou sur l'élément racine MQL5 dans la fenêtre du Navigateur pour récupérer les données depuis le dépôt.
     
   
   

   Nouveaux Projets : Exemples des Détails de Création et d'Opération

   Une nouvelle entité projet a été ajoutée dans MetaEditor. Un projet est un fichier mqproj qui stocke les propriétés communes du programme et les informations sur les fichiers utilisés. Les propriétés du programme peuvent maintenant être gérées depuis une boîte de dialogue séparée de MetaEditor au lieu de modifier manuellement les propriétés dans le code source (en utilisant la directive #property).

   Si vous du code disponible, vous pouvez facilement tester de nouveaux projets en utilisant la commande 'Nouveau Projet depuis une Source'.

   
   
   
   

   Dans le répertoire où est situé le fichier sélectionné, un nouveau fichier projet sera créé avec le même nom et l'extension mqproj. Les principales propriétés du programme spécifiées dans le code source via #property seront automatiquement ajoutées au projet, incluant le nom, le copyright, la version, le lien vers le site web du développeur et la description du programme.

   L'ensemble des propriétés du programme dans le fichier projet a une plus haute priorité que les propriétés spécifiées dans le code du programme. Si les propriétés sont spécifiées à la fois dans le projet et dans le fichier source, seules les propriétés du projet seront utilisées.
   

   
   
   
   

   Deux nouvelles options de compilation des programmes MQL5 ont été ajoutées aux propriétés du projet :

   • Activer l'optimisation supplémentaire : les applications avec l'optimisation désactivée sont compilées plus rapidement mais s'exécutent plus lentement.
     
   • Vérifier les diviseurs à virgule flottante : les applications avec cette vérification désactivée s'exécutent un peu plus rapidement car l'erreur de division par zéro n'est pas vérifiée pendant l'exécution.
   
   

   Pour utiliser les projets, utilisez un onglet Projet séparé dans la fenêtre du Navigateur. Tous les fichiers utilisés dans un projet sont affichés dans cet onglet sous une forme pratique. Lorsqu'un projet est généré depuis un fichier sources, tous les fichiers include utilisés (spécifiés avec la directive #include dans le principal fichier MQ5 et dans ses fichiers include) sont automatiquement ajoutés dans la section Dépendences.

   Lorsqu'un nouveau fichier include est ajouté dans le code source, il apparaît également dans le Navigateur du projet. Les fichiers header utilisés sont ajoutés dans la section Headers ; les images, les sons et les autres programmes MQL5 utilisés dans la section Ressources. Les fichiers MQ5 avec le code source sont affichés dans la section Sources. Dans la section 'Paramètres et fichiers', vous pouvez ajouter d'autres fichiers, tels que les fichiers set pour les tests et les modèles de graphique.

   Utilisez les commandes du menu contextuel pour ajouter les fichiers existants dans un projet ou pour y supprimer des fichiers. Faites attention lors de la suppression de fichiers, car vous pouvez effacer un fichier du projet (enlever le lien) ou le supprimer complètement du disque dur :

   
   
   
   

   La création d'un nouveau projet est aussi facile que la création d'un programme MQL5 normal. Cliquez sur 'Nouveau Projet', sélectionnez le type du nouveau programme et spécifiez les propriétés (telles que le nom, les gestionnaires d'évènements, etc.) dans le MQL5 Wizard.

   Pour obtenir un fichier EX5 exécutable, vous pouvez ouvrir le projet et appuyer sur la touche F7 (la commande de compilation) ou ouvrir le principal fichier MQ5 du programme et le compiler.

   
   

   Projets Partagés dans le MQL5 Storage : Détails des Opérations

   Les projets partagés sont gérés dans une section Projets Partagés séparée. Si vous ne vous êtes pas encore connecté au dépôt, exécutez la commande 'Activer le MQL5 Storage' depuis le mneu contextuel du dossier désiré. MetaEditor vérifiera si votre dépôt contient des données sauvegardées et si des projets partagés sont disponibles pour vous. Toutes les données disponibles seront récupérées depuis le dépôt et téléchargées sur votre ordinateur (opération de checkout). Les projets de groupe disponibles apparaissent dans la section Projets Partagés. Pour récupérer les projets, exécutez "Checkout depuis le Storage" dans le menu contextuel.

   Pour créer un nouveau projet de groupe, sélectionnez le dossier Projets Partagés et cliquez sur "Nouveau Projet" :

   
   

   Complétez ensuite les étapes MQL5 classiques : définissez le type, le nom et les propriétés du programme désiré. Pour les projets de groupe, vous devriez utiliser des noms clairs et compréhensibles afin que les participants les retrouvent facilement. Seuls les caractères latins et les chiffres, sans espace, peuvent être utilisés dans les noms des projets.

   Un objet créé est immédiatement ajouté au MQL5 Storage. Les fichiers de la Bibliothèque Standard utilisés dans le projet ne sont pas ajoutés au dépôt, et vous pouvez les ajouter manuellement.

   Pour permettre aux autres participants de travailler avec le projet, ouvrez ses propriétés. Vous pouvez à partir de là donner les permissions aux utilisateurs sélectionnés en spécifiant leurs identifiants MQL5.community, mais aussi définir les paramètres communs pour le travail du groupe :

   • Projet Privé
   • Projet Libre
   • Projet accessible sur demande
     

   
   
   
   

   Lorsque vous compilez un projet de groupe, le fichier exécutable EX5 est automatiquement copié dans le répertoire Experts, Indicators ou Scripts suivant le type du programme. Cela vous permet d'exécuter instantanément le programme dans le terminal sans avoir à le copier manuellement dans le répertoire correspondant.
   

   
   

   Projets Publics dans le MQL5 Storage : Participation au Développement
   

   Comme mentionné ci-dessus, chaque projet de groupe du MQL5 Storage a des paramètres de publication : le projet peut être privé ou ouvert à d'autres utilisateurs. Maintenant, tous les projets que vous pouvez rejoindre librement sont affichés dans l'onglet "Projets Publics" séparé.

   Chacun peut trouver un projet excitant et prendre part à son développement. Cliquez simplement sur Rejoindre et récupérez le projet depuis le dépôt.

   
   

   
   
   

   Chaque utilisateur qui rejoint le groupe n'a que des droits en lecture seule. Contactez l'auteur du projet pour pouvoir soumettre vos changements. Pour connaître son identifiant, ouvrez les propriétés du projet via le menu contextuel.
   
   
2. Ajout de la possibilité d'insérer facilement des propriétés et des ressources dans le code d'un programme. Par exemple, vous pouvez rapidement ajouter un fichier à inclure dans le code. Utilisez la command "Insérer—MQH comme #include", et sélectionnez le fichier include désiré. La directive #include avec le chemin correct vers le fichier sélectionné sera insérée dans le code du programme.
   

   
   
   
   

   Le même menu permet d'ajouter des fichiers dans le code du programme sous la forme d'un tableau binaire ou de texte. Parmi d'autres, vous pouvez transférer des modèles de graphique avec des Expert Advisors ou des indicateurs : insérez votre modèle dans le code du programme sous la forme d'un tableau, et sauvegardez-le sur le disque en utilisant la fonction FileSave. Après cela, le modèle peut être appliqué sur le graphique désiré directement depuis un Expert Advisor avec la fonction ChartApplyTemplate.
   

   //+------------------------------------------------------------------+
   //| Fonction de démarrage du script                                  |
   //+------------------------------------------------------------------+
   void OnStart()
     {
   //--- Fichier du modèle sous la forme d'un tableau binaire
      unsigned char my_template[]=
        {
         0xFF,0xFE,0x3C, ... ,0x00 // Le tableau des données est raccourci ici
        };
   //--- Sauvegarde et applique le modèle
      if(FileSave("my_template.tpl",my_template))
        {
         Print("Modèle personnalisé sauvegardé dans \\MQL5\\Files");
         if(ChartApplyTemplate(0,"\\Files\\my_template.tpl"))
            Print("Modèle personnalisé appliqué au graphique courant");
         else
            Print("Echec de l'application du modèle personnalisé");
        }
      else
         Print("Echec de la sauvegarde du modèle personnalisé");
     }

   
   
3. Added an option for converting strings between ASCII, HEX and Base64 formats.a Sélectionnez une ligne dans le code source et cliquez sur la commande désirée dans le menu Edition—Convertir :
   

   
   
   

   
   
4. Correction de la recherche insensible à la casse dans les fichiers.
   
5. Correction d'une erreur du débogueur qui pouvait survenir lors du calcul d'expressions du style x.y[0][1].z.
   
6. Correction de la navigation dans le code en utilisant les boutons En Avant et En Arrière.
   

MQL5

1. Le nouveau service en ligne MQL5 Cloud Protector a été ajouté pour fournir une protection supplémentaire aux programmes MQL5. La protection est similaire à l'option utilisée dans la plus grande boutique d'applications de trading, le MetaTrader Market, où les fichiers EX5 des produits soumis par les vendeurs sont également compilés en code natif.
   
   Ce type de protection est maintenant disponible pour tous les utilisateurs de la plateforme. Pour protéger vos fichiers, exécutez la commande suivante dans MetaEditor : Outils—MQL5 Cloud Protector. La seule différence de MQL5 Cloud Protector avec le mécanisme utilisé dans le Market, est que le fichier n'est pas lié à l'ordinateur de l'utilisateur. Les fichiers protégés via le MQL5 Cloud Protector peuvent être exécutés sur n'importe quel ordinateurn comme les fichiers EX5 classiques.
   Le MQL5 Cloud Protector est un service sécurisé. La protection supplémentaires n'est ajoutée qu'au fichier compilé. Le code source n'est pas passé au service. En premier, un programme est compilé dans un fichier EX5 sur l'ordinateur de l'utilisateur ; ensuite, le fichier compilé est envoyé au service via un canal crypté où il est protégé et retourné à l'utilisateur.
   
   
   

   
   

   
   
2. De nouvelles fonctions pour travailler avec les instruments financiers personnalisés ont été ajoutées.
   
   

   Fonction	Action
   CustomSymbolCreate	Crée un symbole personnalisé avec le nom spécifié dans le groupe spécifié
   CustomSymbolDelete	Supprime le symbole personnalisé ayant le nom spécifié
   CustomSymbolSetInteger	Définit la valeur de la propriété de type integer pour un symbole personnalisé
   CustomSymbolSetDouble	Définit la valeur de la propriété de type real pour un symbole personnalisé
   CustomSymbolSetString	Définit la valeur de la propriété de type string pour un symbole personnalisé
   CustomSymbolSetMarginRate	Définit les taux de marge suivant le type de l'ordre et sa direction pour un symbole personnalisé
   CustomSymbolSetSessionQuote	Définit l'heure de début et de fin de la session de cotation spécifiée pour le symbole et le jour de la semaine spécifiés
   CustomSymbolSetSessionTrade	Définit l'heure de début et de fin de la session de trading spécifiée pour le symbole et le jour de la semaine spécifiés
   CustomRatesDelete	Supprime toutes les barres de l'historique des prix du symbole personnalisé dans l'intervalle de temps spécifié
   CustomRatesReplace	Remplace entièrement l'historique des prix du symbole personnalisé dans l'intervalle de temps spécifié avec les données du tableau de données du type MqlRates
   CustomRatesUpdate	Ajoute les barres manquantes dans l'historique du symbole personnalisé et remplace les données existantes avec celles du tableau de données de type MqlRates
   CustomTicksAdd	Ajoute les données d'un tableau de données de type MqlTick à l'historique des prix d'un symbole personnalisé. Le symbole personnalisé doit être sélectionné dans la fenêtre du Market Watch.
   CustomTicksDelete	Supprimer tous les ticks de l'historique des prix du symbole personnalisé dans l'intervalle de temps spécifié
   CustomTicksReplace	Remplace entièrement l'historique des prix du symbole personnalisé dans l'intervalle de temps spécifié et avec les données du tableau de données de type MqlTick

   
   
3. Ajout des Collections de Données Génériques dans la Bibliothèque Standard. Elles contiennet les classes et interfaces permettant de définir des collections basées sur des templates. Les nouvelles collections fortement typées permettent de mieux développer des applications et une meilleure performance de la gestion de nombreuses données.

   La bibliothèque est placée dans le répertoire Include\Generic du répertoire de travail du terminal.

4. Ajout du support des templates pour le type de données union.
5. La propriété SYMBOL_VISIBLE d'un instrument de trading a été ajoutée. L'appel à SymbolInfoInteger(symbol, SYMBOL_VISIBLE) retourne false si le symbole spécifié n'est pas visible dans le Market Watch.
6. Ajout de la nouvelle propriété CHARTEVENT_MOUSE_WHEEL. L'évènement est appelé lorsque la molette de la souris est roulée ou pressée sur le graphique (si CHART_EVENT_MOUSE_WHEEL=true pour le graphique).
   
7. Les propriétés du graphique suivantes ont été ajoutées :
   
   
   • CHART_EVENT_MOUSE_WHEEL — activation/désactivation de la génération de l'évènement CHART_EVENT_MOUSE_WHEEL (défilement de la souris et clic sur le graphique). Valeurs possibles : 0 et 1.
     
   • CHART_CROSSHAIR_TOOL — active/désactive la possibilité de basculer le curseur du mode Crosshair d'un clic du bouton du milieu. Valeurs possibles : 0 et 1.
   • CHART_CONTEXT_MENU — active/désactive l'utilisation du clic droit pour afficher le menu contextuel sur le graphique. Valeurs possibles : 0 et 1.
   
   
8. Le dessin des buffers avec le style DRAW_NONE n'est maintenant pas pris en compte lors du calcul de l'échelle de la fenêtre de l'indicateur.
9. Ajout de la génération de l'évènement CHARTEVENT_CHART_CHANGE lors de la définition de la propriété CHART_SCALEFIX (échelle fixe) pour le graphique.
10. La fonction ArraySwap a été ajoutée, permettant d'intervertir rapidement le contenu des tableaux dynamiques.
    

    bool  ArraySwap(
       void&  array1[],      // Le premier tableau
       void&  array2[]       // Le deuxième tableau
       );

    La fonction accepte des tableaux dynamiques du même type et de même dimension. Pour les tableaux à plusieurs dimensions, le nombre d'éléments doit correspondre dans toutes les dimensions exceptée la première.
    
    
11. Ajout de la nouvelle propriété TERMINAL_RETRANSMISSION — le pourcentage de paquets réseau renvoyés (retransmis) dans le protocole TCP/IP pour les applications et services en cours d'exécution sur un ordinateur donné. La perte de paquets intervient même sur des réseaux ultra-rapides et correctement configurés. Dans ce cas, il n'y a pas de confirmation de livraison des paquets entre le destinataire et l'émetteur. Les paquets perdus sont donc renvoyés.
    
    Le terminal ne calcule pas cette valeur. Elle est demandée au système d'exploitation une fois par minute. Ce n'est pas une indication de la qualité de la connexion entre un terminal particulier et un serveur de trades, puisque le pourcentage est calculé pour l'activité réseau en entier, incluant les activités système et celles en arrière plan.
    
    La propriété TERMINAL_RETRANSMISSION est ajoutée à l'énumération ENUM_TERMINAL_INFO_DOUBLE, la fonction TerminalInfoDouble est utilisée pour l'obtenir.
12. Optimisation de l'utilisation de l'historique de trading.

Signals

1. Correction de l'indication du type de remplissage de l'ordre dans le cas de la fermeture forcée des positions ouvertes suivant un Signal. L'optio 'Stop si le compte est inférieur à XXX USD' est fournie dans les options de copie du signal : si les fonds chutent en-dessous d'un niveau spécifié, la copie des signaux de trading est automatiquement terminée, toutes les positions sont fermées. Auparavant, un type de remplissage incorrect pouvait être défini pour les ordres de fermeture de position dans le cas d'une fermeture forcée. Le terminal vérifie maintenant les types de remplissage autorisés dans les paramètres du symboles et indique l'option correcte.
   

Tester

1. Le comportement de la fonction HistoryOrderSelect dans le Strategy Tester correspond maintenant à la même fonction dans le terminal client.
   
2. Le comportement des fonctions CopyTicks et CopyTicksRange dans le Strategy Tester correspondent maintenant aux mêmes fonctions dans le terminal client.
3. Optimisation de l'affichage des objets graphiques durant un test visuel.
4. Correction de l'affichage des résultats de test des instruments boursiers (avec le modèle de gestion du risque boursier). Le graphique ne montre maintenant que les fonds, tandis que le solde et la charge du dépôt ne sont pas affichés. Le statut de trading de ce type de compte est évalué suivant le niveau des fonds. Le solde ne montre que la quantité d'argent sur le compte et ignore les actifs et passifs du trader. La charge du dépôt (marge/fonds) n'est pas affichée car la marge dans le mode de calcul boursier est égale à la valeur actualisée de l'actif/passif, et elle change avec les fonds.
   

Terminal

1. Il est maintenant possible de créer des instruments financiers personnalisés dans le terminal. Avec cette option, vous pouvez créer n'importe quel symbole, configurer ses paramètre, importer vos données de prix pour le symbole et voir ses graphiques.
   
   Création d'un Symbole Personnalisé
   Ouvrez la fenêtre de gestion des symboles en utilisant le menu contextuel de la fenêtre "Market Watch" et cliquez sur "Créer un Symbole Personnalisé" :
   

   
   

   Un grand nombre de paramètres peuvent être configurés pour un symbole. La liste complète des paramètres et leurs descriptions est disponible dans la documentation. Vous pouvez rapidement configurer votre symbole personnalisé en copiant les paramètres de n'importe quel instrument similaire et en les modifiant. Sélectionnez un symbole existant dans le champ "Copier depuis".
   
   Le nom du symbole personnalisé ne doit pas correspondre aux noms des symboles fournis par les courtiers. Si vous vous connectez au serveur sur lequel un symbole existe avec le même nom, le symbole personnalisé sera effacé.
   
   Des commandes d'import et d'export des paramètres sont également disponibles ici. Vous pouvez facilement partager des symboles personnalisés ou transférer des symboles entre vos terminaux. Les paramètres sont exportés dans des fichiers texte au format JSON.
   
   Gestion des Symboles Personnalisés
   Tous les symboles sont affichés dans un groupe Custom séparé. Si vous avez besoin de modifier ou d'effacer un symbole, utilisez le menu contextuel de la liste :
   

   
   

   
   Import de l'Historique des Prix
   Vous pouvez importer des données de prix pour votre symbole personnalisé depuis n'importe quel fichier texte, mais aussi depuis des fichiers d'historique MetaTrader au format HST et HCC. Choisissez un symbole et allez dans l'onglet "Barres". L'import des ticks n'est pas encore supporté.
   

   
   

   Dans la boîte de dialogue d'import, spécifier le chemin vers le fichier et remplissez les paramètres requis :
   
   
   • Séparateur — le séparateur des éléments dans un fichier texte.
   • Ignorer des colonnes et des lignes — nombre de colonnes (de gauche à droite) et de lignes (de haut en bas) à ignorer pendant l'import.
   • Décalage — décalage horaire en heures. L'option est utilisée lors de l'import de données sauvées dans un fuseau horaire différent.
   • Utiliser la sélection uniquement — n'importe que les lignes sélectionnées dans la zone de visualisation des lignes. Vous pouvez sélectionner des lignes avec la souris tout en maintenant les touches Ctrl ou Shift.
   
   Un fichier avec des barres en 1 minute doit avoir le format suivant : Date Time Open High Low Close TickVolume Volume Spread. Par exemple :
   
   2016.06.27    00:01:00    1.10024    1.10136    1.10024    1.10070    18    54000000    44
   2016.06.27    00:02:00    1.10070    1.10165    1.10070    1.10165    32    55575000    46
   2016.06.27    00:03:00    1.10166    1.10166    1.10136    1.10163    13    13000000    46
   2016.06.27    00:04:00    1.10163    1.10204    1.10155    1.10160    23    51000000    41
   
   Vous pouvez utiliser les données de n'importe quel instrument existant pour votre symbole personnalisé. Exportez les données (l'option a été ajoutée dans la version précédente de la plateforme), modifiez-les si nécessaire et ré-importez les données.
   
   L'historique des prix est stocké sous le forme de barres 1-minute dans MetaTrader 5. Toutes les autres périodes sont créées sur la base de ces barres. Vous pouvez également importer les données de périodes supérieures, mais les graphiques sur des périodes inférieures auront des gaps dans ce cas. Par exemple, si vous importez des données 1-heure, une barre par heure sera affichée dans le graphique M1.
   
   Les données de prix des symboles personnalisés sont sauvegardés dans un répertoire Custom séparé (et non pas dans les répertoires où les serveurs de trades sont sauvegardés) :
   
   C:\Users\[compte windows]\AppData\Roaming\MetaQuotes\Terminal\[instance id]\bases\Custom
   
   
   Utilisation des Symboles Personnalisés
   L'utilisation des symboles personnalisés est similaire à l'utilisation des instruments fournis par le courtier. Les symboles personnalisés sont affichés dans la fenêtre du Market Watch ; vous pouvez ouvrir les graphiques de cs symboles et leur appliquer des indicateurs et des objets d'analyse. Les symboles personnalisés ne peuvent pas être tradés.
   
   Test de Stratégies sur des Symboles Personnalisés
   Les symboles personnalisés peuvent être utilisés pour tester des robots de trading et des indicateurs dans le strategy tester. Ceci permet d'optimiser des stratégies même pour des symboles financiers qu'un courtier ne peut pas fournir actuellement. Vous n'avez qu'à importer l'historique correctement et à configurer les propriétés du symbole personnalisé.
   

   
   
   

   Lors du calcul de la marge et du profit, le strategy tester utilise automatiquement les taux croisés disponibles. Supposons que nous avons créé le symbole personnalisé AUDCAD.custom avec le type Forex de calcul de marge et que notre devise de compte est l'USD. Dans ce cas, le testeur recherche les symboles nécessaires dans l'ordre suivant basé sur le nom du symbole Forex :
   
   1.     en premier, la recherche est effectuée pour les symboles AUDUSD.custom (pour calculer la marge) et USDCAD.custom (pour calculer le profit du trade)
   2.     si l'un de ces symboles n'est pas présent, la recherche est effectuée pour le premier symbole correspondant à la paire de devises nécessaires par son nom (AUDUSD et USDCAD respectivement). Par exemple, les symboles AUDUSD.b et NZDUSD.b ont été trouvés. Cela signifie que leurs taux seront utilisés pour calculer la marge et le profit.
   
   Les instruments avec d'autres types de calcul de marge (Futures et Actions) nécessitent une paire de devises pour convertir la devise de l'instrument dans la devise de dépôt. Supposons que nous avons créé un symbole personnalisé avec les devises de profit et de marge exprimées en GBP, tandis que la devise du dépôt est CHF. Dans ce cas, la recherche des symboles de test est effectuée dans l'ordre suivant :
   
   1. La présence d'un symbole de trading correspondant à GBPCHF (GBP vs CHF) est vérifiée.
   2. Si un tel symbole n'existe pas, la recherche est effectuée pour le premier symbole de trading correspondant à GBPCHF par son nom, par exemple GBPCHF.b ou GBPCHF.def.
   
   Lors du test d'applications utilisant des instruments personnalisés, assurez-vous que le compte de trading a touts les paires de devises nécessaires. Autrement, le calcul des résultats financiers et des besoins de marge pendant le test ne sera pas possible.
   
   Plus de possibilités seront disponibles dans les prochaines versions de la plateforme.
   Le développement des symboles personnalisés n'est pas encore terminé, et plus de fonctions seront ajoutées dans les prochaines versions de la plateforme. Vous pourrez importer l'historique dans les symboles personnalisés directement depuis les Expert Advisors, mais aussi diffuser les données (ajouter des cotations) de ces symboles en temps réel.
   
   
2. Ajout du filtre de la fonctionnalité Time & Sales par volume.
   
   Les transactions avec un volume inférieur à la valeur spécifiée peuvent être cachées du tableau Time & Sales. Si ce filtre est appliqué, seules les transactions avec un gros volume apparaîtront dans la fenêtre Time & Sales.
   
   Double cliquez sur la première ligne dans la fenêtre Time & Sales, spécifiez le volume minimum en lots et cliquez ensuite sur n'importe quelle autre zone du Market Depth. Les trades seront filtrés et la valeur actuelle du filtre sera affichée dans l'en-tête de la colonne du volume.
   

   
   

   
   

   Vous pouvez également spécifier le volume minimum en utilisant le menu contextuel du Time & Sales.
   
   
3. Ajout d'une option pour lier le Market Depth à un graphique actif. Chaque fois que vous basculez vers le graphique d'un instrument financier, cet instrument sera automatiquement activé dans la fenpetre du Market Depth. Vous n'aurez donc plus besoin d'ouvrir la fenêtre du Market Depth pour chaque nouveau symbole.
   

   
   

   
   
4. Correction du rafraîchissement des barres d'outils après avoir minimisé puis maximisé la fenêtre du terminal.
5. Correction de la génération de l'historique de trading d'une position si les tickets de la transaction et de la position se chevauchent.

MQL5

1. Ajout d'une option pour profiler les programmes MQL5 sur un historique des prix. Cette option permet de vérifier les performances des programmes sans attendre de nouveaux ticks.
   
   Lors du profilage sur la base de données réelles, le programme est lancé dans un graphique normal du terminal. De nombreux programmes, spécialement les indicateurs, effectuent uniquement les calculs à l'arrivée d'un nouveau tick (OnTick, OnCalculate). Pour évaluer les performances, vous devez donc attendre l'arrivée de nouveaux ticks en temps réel. Si vous testez un programme en utilisant des données historiques, vous pouvez immédiatement fournir les données nécessaires. Le profilage est lancé en mode visuel dans le Strategy Tester, et vous recevez beaucoup d'évènements de nouveaux ticks à la fois.
   

   
   

   
   
2. Ajout du support des unions. L'union est un type de donnée spécial consistant en plusieurs variables partageant la même zone mémoire. L'union fournit donc la possibilité d'interpréter la même séquence de bits en deux (ou plus) façons différentes. La déclaration d'une union commence avec le mot-clé 'union'.
   

   union LongDouble
   {
     long   long_value;
     double double_value;
   };

   Contrairement à une structure, différents membres d'une union appartiennent à la même zone mémoire. Dans cet exemple, l'union LongDouble est déclarée avec des valeurs de type long et double partageant la même zone mémoire. Veuillez noter qu'il est impossible de stocker dans l'union une valeur de type long integer et une valeur double réelle simultanément (contrairement à une structure), puisque les variables long_value et double_value se chevauchent (en mémoire). D'un autre côté, un programme MQL5 est capable de traiter des données contenant dans l'union une valeur de type integer (long) ou réelle (double) n'importe quand. L'union permet donc de reçevoir deux (ou plus) options pour représenter la même séquence de données.
   
   Pendant la déclaration d'une union, le compilateur alloue automatiquement la zone mémoire suffisante pour stocker le type le plus grand (en volume) dans la variable de l'union. La même syntaxe est utilisée pour accéder à un élément de l'union que pour une structure, c'est à dire l'opérateur point.
   

   union LongDouble
   {
     long   long_value;
     double double_value;
   };
   //+------------------------------------------------------------------+
   //| Fonction de démarrage du script                                  |
   //+------------------------------------------------------------------+
   void OnStart()
     {
   //---
      LongDouble lb;
   //--- récupère et affiche le nombre invalide -nan(ind)
      lb.double_value=MathArcsin(2.0);
      printf("1.  double=%f                integer=%I64X",lb.double_value,lb.long_value);
   //--- plus grande valeur normalisée (DBL_MAX)
      lb.long_value=0x7FEFFFFFFFFFFFFF;
      printf("2.  double=%.16e  integer=%I64X",lb.double_value,lb.long_value);
   //--- plus petite valeur normalisée (DBL_MIN)
      lb.long_value=0x0010000000000000;    
      printf("3.  double=%.16e  integer=%.16I64X",lb.double_value,lb.long_value);
     }
   /*  Résultat de l'exécution
       1.  double=-nan(ind)                integer=FFF8000000000000
       2.  double=1.7976931348623157e+308  integer=7FEFFFFFFFFFFFFF
       3.  double=2.2250738585072014e-308  integer=0010000000000000
   */

   
   
3. Ajout de la génération automatique d'un opérateur de copie implicite pour les objets des structures et des classes. Le compilateur crée maintenant automatiquement les opérateurs de copie, qui permettent d'écrire des entrées simples pour les objets, tel que b=a :
   

   class Foo
     {
      int               value;
   public:
      string Description(void){return IntegerToString(value);};
      //--- constructeur par défaut
                        Foo(void){value=-1;};
      //--- constructeur paramétré   
                        Foo(int v){value=v;};
     };
   //+------------------------------------------------------------------+
   //|  structure contenant des objets de type Foo                      |
   //+------------------------------------------------------------------+
   struct MyStruct
     {
      string            s;
      Foo               foo;
     };
   //+------------------------------------------------------------------+
   //| Fonction de démarrage du programme                               |
   //+------------------------------------------------------------------+
   void OnStart()
     {
   //---
      MyStruct a,b;
      Foo an_foo(5);
      a.s="test";
      a.foo=an_foo;
      Print("a.s=",a.s," a.foo.Description()=",a.foo.Description());
      Print("b.s=",b.s," b.foo.Description()=",b.foo.Description());
   //---
      Print("b=a");
      b=a;
   //---
      Print("a.s=",a.s," a.foo.Description()=",a.foo.Description());
      Print("b.s=",b.s," b.foo.Description()=",b.foo.Description());
   /*
      Résultat de l'exécution;
      a.s=test a.foo.Description()=5
      b.s= b.foo.Description()=-1
      b=a
      a.s=test a.foo.Description()=5
      b.s=test b.foo.Description()=5
   */
     }

   La copie des membres des objets est effectuée dans l'opérateur implicite.
   
   
   • Si un membre est un objet, l'opérateur de copie correspondant à cet objet est appelé.
   • Si un membre est un tableau d'objets, le tableau destination est agrandi ou réduit à la taille nécessaire en utilisant ArrayResize avant d'appeler l'opérateur de copie correspondant à chaque élément.
     
   • Si un membre est un tableau d'objets simples, la fonction ArrayCopy est utilisée pour la copie.
   • Si un membre est un pointeur sur un objet, le pointeur est copié plutôt que l'objet sur lequel il pointe.
   
   Si nécessaire, vous pouvez surcharger le comportement et créer votre propre comportement au lieu de celui d'un opérateur de copie implicite, en utilisant la surcharge.
   
   
4. Optimisation de la mémoire utilisée lors de l'accès à l'historique des prix depuis les Expert Advisors utilisant les fonctions Copy*. La consommation de la mémoire sera réduite énormément lors de l'utilisation de grandes quantités de données.
   
   
5. La fonction TimeToStruct retourne maintenant une valeur de type boolean, permettant de vérifier le succès de la conversion d'une datetime en MqlDateTime.
   
6. Ajout de l'interdiction d'utiliser les fonctions FileWriteStruct et FileReadStruct pour les structures contenant des string, des tableaux dynamiques, des objets et des pointeurs.
7. Les codes de retour suivants ont été ajoutés :
   
   
   • TRADE_RETCODE_REJECT_CANCEL — la requête d'activation d'un ordre en attente est rejetée, l'ordre est annulé
     
   • TRADE_RETCODE_LONG_ONLY — la requête est rejetée car la règle "Seules les positions long sont autorisées" est définie pour le symbole
     
   • TRADE_RETCODE_SHORT_ONLY — la requête est rejetée car la règle "Seules les positions short sont autorisées" est définie pour le symbole
     
   • TRADE_RETCODE_CLOSE_ONLY — la requête est rejetée car la règle "Seules les clôtures des positions existantes sont autorisées" est définie pour le symbole
     
     
8. Ajout de la valeur de retour de la fonction SymbolInfoInteger avec le paramètre SYMBOL_ORDER_MODE. SYMBOL_ORDER_CLOSEBY — permission d'une opération Close By, c'est à dire la clôture d'une position par une position opposée.
9. La propriété de type boolean SYMBOL_CUSTOM a été ajoutée à l'énumération ENUM_SYMBOL_INFO_INTEGER. La propriété permet de savoir si un symbole est un symbole personnalisé. Utilisez la fonction SymbolInfoInteger pour récupérer la propriété.
10. Il est maintenant possible d'obtenir la raison de la création d'un ordre, d'une transaction ou d'une position.
    
    Nouvelles propriétés
    
    • La nouvelle propriété POSITION_REASON pour une position a été ajoutée. Elle peut être obtenue en utilisant PositionGetInteger.
    • La nouvelle propriété DEAL_REASON pour une transaction a été ajoutée. Elle peut être obtenue en utlisant HistoryDealGetInteger.
    • La nouvelle propriété ORDER_REASON pour un ordre a été ajoutée. Elle peut être obtenue en utilisant OrderGetInteger et HistoryOrderGetInteger.
    
    Raisons pour la création d'un ordre, d'une transaction et d'une position
    Trois variables ont été ajoutées pour obtenir les raisons de la création d'opérations de trading :
    

    ENUM_POSITION_REASON	ENUM_DEAL_REASON	ENUM_ORDER_REASON	Description de la raison
    POSITION_REASON_CLIENT	DEAL_REASON_CLIENT	ORDER_REASON_CLIENT	L'opération a été exécutée en raison de l'activation d'un ordre placé depuis un terminal de bureau
    POSITION_REASON_MOBILE	DEAL_REASON_MOBILE	ORDER_REASON_MOBILE	L'opération a été exécutée en raison de l'activation d'un ordre placé depuis une application mobile
    POSITION_REASON_WEB	DEAL_REASON_WEB	ORDER_REASON_WEB	L'opération a été exécutée en raison de l'activation d'un ordre placé depuis une plateforme web
    POSITION_REASON_EXPERT	DEAL_REASON_EXPERT	ORDER_REASON_EXPERT	L'opération a été exécutée en raison de l'activation d'un ordre placé depuis un programme MQL5, c'est à dire par Expert Advisor ou un script
    -	DEAL_REASON_SL	ORDER_REASON_SL	L'opération a été exécutée en raison de l'activation d'un Stop Loss
    -	DEAL_REASON_TP	ORDER_REASON_TP	L'opération a été exécutée en raison de l'activation d'un Take Profit
    -	DEAL_REASON_SO	ORDER_REASON_SO	L'opération a été exécutée en raison d'un évènement Stop Out
    -	DEAL_REASON_ROLLOVER	-	La transaction a été exécutée en raison d'un rollover
    -	DEAL_REASON_VMARGIN	-	La transaction a été exécutée après la facturation de la marge de variation
    -	DEAL_REASON_SPLIT	-	La transaction a été exécutée après le découpage (réduction du prix) d'une action ou d'un autre actif, qui a ouvert une position au moment de l'annonce du découpage

    
    
11. Optimisation de la synchronisation et de l'accès à l'historique des ticks.
12. Correction du retour des ticks dans un tableau statistique dans la fonction CopyTicksRange. Dans les précédentes versions, la fonction ne retournait aucun tick dans ce cas.
13. Diverses corrections ont été apportées dans la Bibliothèque de Logique Floue.

Signals

1. Correction de l'ouverture d'un signal depuis le site web lorsqu'un compte de trading n'est connecté.

Tester

1. Optimisation et accélération du travail avec l'historique des ordres et des transactions. La vitesse d'opération sera augmentée énormément lors de l'utilisation de grandes quantités de données (dizaines de milliers d'entrées dans l'historique).
2. Correction du calcul de la durée de détention d'une position dans le rapport de test.

MetaEditor

1. Correction de l'affichage du contenu des tableaux membres de classe statique dans le debugger.
2. Ajout d'une liste de points d'arrêt dans le programme en cours de déboguage. La liste peut être ouverte avec le menu contextuel dans l'onglet Debug :
   

   
   

   Pour aller sur un point d'arrêt, double cliquez dessus.

Terminal

1. Ajout de l'accès à l'historique des barres et des ticks. Il est maintenant possible de télécharger depuis le serveur l'historique complet des barres 1-minute et des ticks via l'interface de la plateforme de trading, et non plus seulement grâce au langage MQL5. L'accès aux données des prix est étendu en préparation du lancement des fonctions personnalisées de flux de données. Dans un futur proche, la plateforme fournira la possibilité de construire des graphiques basés sur les données de prix des utilisateurs, de créer des symboles synthétiques et d'utiliser des graphiques hors ligne.
   
   Pour télécharger les données, ouvrez la fenêtre de gestion des symboles depuis le menu contextuel de la fenêtre "Market Watch" :
   

   
   
   

   L'écran contient deux onglets : "Barres" et "Ticks". Sélectionnez le symbole, l'intervalle de temps désiré et cliquez sur "Demander". La plateforme demandera au serveur toutes les données disponibles et affichera immédiatement les données si elles ont été téléchargées. Les données de prix sauvegardées peuvent être exportées dans un fichier CSV.
   
   
2. Ajout de l'affichage de l'heure avec une précision en milliseconde pour les positions, les transactions et les ordres.
   

   
   
   

   
   
3. Dans la fenêtre de trade, correction des notifications sur le refus d'exécution d'une demande Close By.
   

MQL5

1. Correction de la fonction PositionSelect. La fonction pouvait occasionnellement sélectionner une position différente de celle ayant le plus petit numéro de ticket.
2. Correction du fonctionnement des fonctions CopyTicks et CopyTicksRange lors de la demande de trop nombreuses données de l'historique des ticks.
   

Signaux

1. Correction des opérations de copie qui augmente la taille d'une position existante. L'erreur pouvait occasionnellement survenir sur les comptes avec du netting.
   

Tester

1. Correction du traitement des ordres limit pour les instruments boursiers. Les ordres placés comme étant meilleurs que le marché (le prix d'achat est inférieur au prix du marché ou le prix de vente est supérieur au prix du marché) sont exécutés sans slippage. Les ordres placés comme étant pires que le prix du marché sont exécutés immédiatement au prix du marché à l'heure de placement de l'ordre.
   

Mise à jour de la documentation.

Terminal

1. Amélioration de la vitrine du MetaTrader Market, la boutique d'applications. Vous pouvez maintenant naviguer parmi les robots de trading et les indicateurs techniques de façon plus pratique. Nous avons amélioré le design et ajouté la sélection de produits :
   
   
   • La page principale présente maintenant les experts et les indicateurs les plus populaires, les nouveaux produits du Market, mais aussi les meilleures applications gratuites.
   • Les sections Experts, Indicateurs et Utilitaires ont maintenant des sous-sections : robots de grille et de hedging, indicateurs de tendances et multi-devises, et bien plus encore.
     

   
   
   
   

2. Correction de la mise à jour du terminal client et des achats intégrés dans le Market, dans le service Signaux et pour l'Hébergement Virtuel lors de l'utilisation d'un compte Windows disponsant de droits limités.
   
3. Correction du tri parfois incorrect de l'historique des positions.
4. Optimisation et correction de l'affichage dans l'onglet Exposition.
   

MQL5

1. Ajout du support des surcharges des template de fonctions utilisant des paramètres. Par exemple, nous avons un template de fonction écrivant la valeur du second paramètre dans le premier en utilisant du casting de type. MQL5 ne permet pas de caster le type string vers le type bool. Cependant, nous pouvons le faire nous-mêmes. Créons une surcharge d'un template de fonction :
   

   //+------------------------------------------------------------------+
   //| Template de fonction                                             |
   //+------------------------------------------------------------------+
   template<typename T1,typename T2>
   string Assign(T1 &var1,T2 var2)
     {
      var1=(T1)var2;
      return(__FUNCSIG__);
     }
   //+------------------------------------------------------------------+
   //| Surcharge spéciale pour bool+string                              |
   //+------------------------------------------------------------------+
   string Assign(bool &var1,string var2)
     {
      var1=(StringCompare(var2,"true",false) || StringToInteger(var2)!=0);
      return(__FUNCSIG__);
     }
   //+------------------------------------------------------------------+
   //| Fonction de lancement du programme                               |
   //+------------------------------------------------------------------+
   void OnStart()
     {
      int i;
      bool b;
      Print(Assign(i,"test"));
      Print(Assign(b,"test"));
     }

   Nous pouvons voir dans le résultat de l'exécution que le template de fonction Assign() a été utilisé pour la paire int+string, tandis que la version surchargée a déjà été utilisée pour la paire bool+string pendant le deuxième appel.
   

   string Assign<int,string>(int&,string)
   string Assign(bool&,string)

   
   
2. Ajout de la spécialisation explicite des templates de fonctions. Pour cela, spécifiez les paramètres de type avant la liste des paramètres d'appel :
   

   template<typename T>
   T Func() { return (T)0; }
     
     
   void OnInit()
     {
      Func<double>();   // spécialisation explicite du template de fonction
     }

   Le changement de type est effectué par la spécification explicite des types plutôt que via les paramètres d'appel.
   
   
3. Optimisation de l'affichage des indicateurs personnalisés avec le type de dessin DRAW_ZIGZAG.
4. Ajout de nouvelles valeurs dans l'éunumération des types de deal ENUM_DEAL_TYPE :
   
   
• DEAL_DIVIDEND — opération de dividendes.
  
• DEAL_DIVIDEND_FRANKED — opération de dividendes franche (la taxe est payée par une société, pas par le client).
  
• DEAL_TAX — facturation d'une taxe.
  
  
5. Correction de l'affichage des indicateurs personnalisés avec le type de dessin DRAW_FILLING. Dans le cas où les coordonnées des lignes supérieure et inférieure correspondent, une fine ligne est dessinée.
6. Correction du calcul des coordonnées de l'objet Etiquette Bitmap lors de la définition du paramètre CHART_SHOW à 'false'. Le paramètre est défini par la fonction ChartSetInteger et permet de cacher tous les éléments du graphique des prix pour créer une interface personnalisée.
   
7. Correction du ré-encodage des images 24 bits lors de leur placement dans les ressources des applications MQL5.
8. Correction de l'affichage des structures avec la fonction ArrayPrint.
9. Mise à jour des bibliothèques standards MQL5.
   

MetaEditor

1. Ajout de la traduction de l'interface utilisateur en malais.
   

Signaux

1. Correction de l'ouverture de la page d'un signal dans le terminal depuis le site Internet de la MQL5.community si aucun compte de trading n'est connecté.
   

Tester

1. Correction du fonctionnement de la fonction CopyTicks dans le strategy tester.
2. Corretion du tri des trades de Retrait lors de la génération d'un rapport.
3. Correction de la modification des ordres en attente.

Hébergement

1. Correction de l'affichage de l'assistant d'hébergement virtuel sur les écrans en ultra-haute résolution (4К).

Mise à jour de la documentation.

Terminal

1. Basculement rapide entre les fenêtres 'Boîte à Outils' et 'Strategy Tester'.
   

   
   
   

2. Nouvelle option permettant d'éditer les prix et les volumes des ordres avec la molette de la souris :

   
   
   

   
   
3. Lorsque vous téléchargez les terminaux mobiles, la liste de vos serveurs de trading est dorénavant conservée. Lors de l'installation de MetaTrader sur votre iPhone ou votre appareil Android, la liste de vos serveurs est alors affichée. Vous pouvez vous connecter rapidement à votre compte de trading existant. Le serveur du compte actuellement connecté sera affiché en premier dans le terminal mobile.
   

   
   
   

   
   
4. Réduction significative de la charge du terminal, crée par les objets et graphiques invisibles (minimisés).
   
5. Correction du déclenchement occasionnel et incorrect des niveaux des stops suiveurs.
6. Correction du filtre des trades par symbole dans l'historique du compte de trading.
7. Correction de l'affichage du champ 'Type' dans l'historique des positions.
8. Correction de la présentation de l'historique de trading sous la forme des positions.

MQL5

1. Correction de l'affichage des indicateurs personnalisés dont le type de dessin est DRAW_COLOR_LINE, DRAW_COLOR_ZIGZAG et DRAW_COLOR_SECTION, dans le cas où CLR_NONE est utilisé pour la couleur.
2. Correction du typage des modèles utilisant un pointeur constant.
3. Correction du contrôle d'accès aux membres de classe privés et protégés.

Tester

1. Correction de l'activation des ordres limit sur les instruments boursiers, lorsque le prix de déclenchement de l'ordre n'est pas meilleur que le prix actuel du marché (le prix Buy est supérieur ou le prix Sell est inférieur au prix du marché).
2. Suppression de la restriction liée au test des indicateurs personnalisés ayant plus de 64 paramètres d'entrée.
3. Ajout de la traduction de l'interface en hindi.

Mise à jour de la documentation.

Terminal

1. L'historique de trading peut maintenant être affiché sous forme de ses positions. Le terminal collecte les données des transactions liées à une position (ouverture, volume supplémentaire, clôture partielle ou complète) et les regroupe ensuite en un seul enregistremement contenant les détails suivants :
   
   
   • Heure d'ouverture et de clôture de la position déterminées par la première et la dernière transaction respectivement
     
   • Volume de la position. Si une partie de la position a été fermée, l'enregistrement cotient le volume fermé et le volume d'origine
   • Le prix d'ouverture moyen pondéré de la position et son prix de clôture
   • Le résultat financier total des transactions liées à la position
     

   
   
   

   
   Sur les comptes utilisant le hedging, la nouvelle forme de l'historique est similaire à l'historique de compte dans MetaTrader 4.
   

   
   
   

   
   
2.   Une nouvelle commande a été ajouté, permettant de visualiser les trades sur le graphique du symbole.
   
   
   • Si vous souhaitez afficher les transactions d'une position ou d'un symbole sélectionné, cliquez sur "Ajouter les Transactions de [nom du symbole]". Les transactions correspondantes seront affichées sur tous les graphiques actuellement ouverts du symbole sélectionné. Si aucun graphique pour ce symbole n'est ouvert, un nouveau graphique sera créé.
   • Cliquez sur "Ajouter Toutes les Transactions" pour afficher toutes les transactions de tous les symboles de l'historique de trading. Les transactions des symboles correspondants seront ajoutées à tous les graphiques ouverts.

   
   
   

   
   
3. Ajout de l'affichage du nom international de l'instrument de trading dans les spécifications du contrat, et possibilité de rechercher un symbole par son nom international dans la fenêtre de gestion des symbole.
   

   
   
   

   
   
4. Ajout d'une commande pour la configuration de la résolution de la fenêtre du terminal. La fonction sera utile pour enregistrer des vidéos. Le menu fournit les options de résolutions les plus courantes, utilisées par différents services de vidéos tel que YouTube.
   

   
   
   

5. Les modèles de graphiques et les profils ont été déplacés de [Répertoire des Données du Terminal\Profiles] vers [Répertoire des Données du Terminal\MQL5\Profiles]. Vous pouvez maintenant facilement ajouter des modèles au Dépôt MQL5 et y accéder depuis n'importe quel PC.
   

MQL5

1. Ajout du support des variables de ressource. Le développement de certains programmes peut être grandement facilité en ajoutant ce type de variables. Vous pouvez par exemple écrire le code d'un programme OpenCL dans un fichier CL séparé et l'inclure ensuite sous la forme d'une chaîne de caractères dans les ressources de votre programme MQL5. Avant la mise à jour, ce type de code devait être décrit comme une seule grosse chaîne de caractères.
   
   Déclaration d'une variable de ressource
   

   #resource chemin_vers_le_fichier_de_ressource as type_de_la_variable_de_ressource nom_de_la_variable_de_ressource

   
   Fonctionnalités
   
   • L'encodage des fichiers de chaînes de caractères est déterminé automatiquement suivant le BOM (octets spécifiques de l'en-tête du fichier). Si le BOM est manquant, l'encodage est défini par le contenu du fichier. ANSI, UTF-8 et UTF-16 sont supportés. Toutes les chaînes de caractères sont converties en Unicode.
     
   • Les données d'une telle ressource ne peuvent être utilisées que par le biais d'une variable. L'adressage automatique avec "::<nom_de_la_ressource>" n'est pas disponible.
   • Le type spécial de variable de ressource bitmap indique au compilateur que la ressource est une image. Dans ce cas, la variable de ressource est de type uint.
   • Lors de l'utilisation d'une image en 24 bits, le canal alpha est défini à 255 pour tous les pixels de l'image.
   • Lors de l'utilisation d'une image en 32 bits sans le canal alpha, celui-ci est défini à 255 pour tous les pixels de l'image.
   • Lors du chargement d'une image 32 bits avec un canal alpha, les pixels ne sont pas traités de cette façon.
   • La tableau de type bitmap de la variable de ressource peut avoir 2 dimensions. Dans ce cas, la taille du tableau est définie comme [hauteur_image ][ largeur_image ].
   • Si un tableau à 1 dimension est spécifié, le nombre d'éléments est égal à hauteur_imaget*largeur_image.
   • Si la taille du fichier de ressource n'est pas un multiple de la taille d'un élément du tableau, les données restantes seront coupées. Par exemple, si la taille du fichier est de 14 octets, pour un tableau de int, le nombre d'éléments sera égal à 3, et les 2 octets restants (14 - sizeof(int)*3) seront perdus.
   
   Exemples d'Utilisation
   

   #resource "data.bin" as int ExtData[]             // déclaration d'un tableau numérique contenant les données du fichier data.bin
   #resource "data.bin" as MqlRates ExtData[]        // déclaration d'un tableau de structures simples contenant les données du fichier data.bin
   
   #resource "data.txt" as string ExtCode            // déclaration d'une chaîne de caractères contenant les données du fichier data.txt
   #resource "data.txt" as string ExtCode[]          // déclaration d'une chaîne de caractères contenant les données du fichier data.txt
   
   #resource "image.bmp" as bitmap ExtBitmap[]       // déclaration d'un tableau à 1 dimension contenant un bitmap du fichier BMP, taille du tableau = largeur * hauteur
   #resource "image.bmp" as bitmap ExtBitmap2[][]    // déclaration d'un tableau à 2 dimensions contenant un bitmap du fichier BMP, taille du tableau = [hauteur][largeur]
   

   
   
2. La nouvelle propriété CHART_SHOW permet de désactiver l'affichage du graphique. Les fonctions ChartGetInteger et ChartSetInteger sont utilisées pour récupérer et définir la propriété.
   
   Si false, le dessin des attributs du graphique des prix est désactivé et toutes les règles en bordure sont supprimées, incluant les échelles de temps et de prix, la barre de navigation rapide, les étiquettes des évènement du Calendrier, les étiquettes des trades, les infobulles des indicateurs et des barres, les sous-fenêtres d'indicateurs, les histogrammes de volume, etc.
   
   La désactivation du dessin est la solution parfaite pour créer des interfaces personnalisées de programmes en utilisant des resources graphiques.
   
   Les objets graphiques sont toujours dessinés, indépendamment de la valeur de la propriété CHART_SHOW.
   
   
3. La nouvelle propriété CHART_KEYBOARD_CONTROL permet d'activer/désactier le contrôle du graphique avec le clavier ("Début", "Fin", "Page Précédente", "+", "-", "Flèche vers le haut", etc.). La définition de CHART_KEYBOARD_CONTROL à false désactive le défilement et la mise à l'échelle du graphique tout en laissant intacte la possibilité de reçevoir les évènements d'appuis de touches dans la fonction OnChartEvent().
   
   Les fonctions ChartGetInteger et ChartSetInteger permet de récupérer et de définir la propriété.
   
   
4. Ajout de nouvelles fonctions pour travailler avec OpenCL.
   
   Nouvelles propriétés pour travailler avec la mémoire
   4 nouvelles propriétés peuvent être reçues par la fonction CLGetInfoIntegrer :
   
   • CL_DEVICE_MAX_WORK_GROUP_SIZE — le nombre total de groupes de travail locaux disponibles pour un périphérique OpenCL.
     
   • CL_KERNEL_WORK_GROUP_SIZE — le nombre total de groupes de travail locaux disponibles pour un programme OpenCL.
     
   • CL_KERNEL_LOCAL_MEM_SIZE — la taille de la mémoire locale en octets utilisée par un programme OpenCL pour résoudre toutes les tâches parallèles dans un groupe. Utilisez CL_DEVICE_LOCAL_MEM_SIZE pour récupérer la valeur disponible maximum.
     
   • CL_KERNEL_PRIVATE_MEM_SIZE — la taille minimum de mémoire privée (en octets) utilisée par chaque tâche dans le noyau du programme OpenCL.
   
   bool CLExecutionStatus(int kernel)
   Retourne le statut de l'exécution du programme OpenCL. Le handle du noyau du programme OpenCL est passé en paramètre.
   
   bool CLSetKernelArgMemLocal(int kernel_handle,int arg_index,ulong local_mem_size)
   Définit le buffer local comme arguement de la fonction du noyau. Le handle du noyau du programme OpenCL, le nombre d'arguments de la fonction OpenCL et la taille du buffer sont passés en paramètres.
   
   
5. Un nouveau code de réponse TRADE_RETCODE_LIMIT_POSITIONS a été ajouté. Le nombre de positions ouvertes présentes en même temps sur un compte peut être limité dans les paramètres du serveur. Lorsque cette limite est atteinte, le serveur retourne l'erreur TRADE_RETCODE_LIMIT_POSITIONS lors du placement d'un nouvel ordre. La limite agit différemment suivant le type de comptabilisation des positions :
   
   
   • Netting — le nombre de positions ouvertes est utilisé. Lorsque la limite est atteinte, la plateforme désactive le placement de nouveaux ordres dont l'exécution augmenterait le nombre de positions ouvertes. En fait, la plateforme ne permet le placement d'ordres que pour les symboles ayant déjà des positions ouvertes. Les ordres en attente actuels ne sont pas pris en compte puisque leur exécution pourrait changer les positions courantes mais pas augmenter leur nombre.
   • Hedging — les ordres en attente sont pris en compte avec les positions ouvertes puisque leur activation génère toujours l'ouverture d'une nouvelle position. Lorsque la limite est atteinte, la plateforme désactive le placement de nouveaux ordres au marché pour ouvrir des positions d'ordres en attente.
   
   
6. Correction d'une erreur pouvant générer un saut de ticks dans l'historique des ticks.
7. Correction d'erreurs indirectes de saisie des modèles.
8. Mise à jour de la bibliothèque de fonctions statistiques mathématiques.
   

Market

1. Correction de l'ouverture de la page du produit lors du téléchargement d'une version de démo.
   

Tester

1. Après la fin de l'optimisation, les résultats sont maintenant triés automatiquement dans la colonne "Résultats".
2. La nouvelle commande "Basculer vers les Résultats d'Optimisation" du menu contextuel de l'onglet des résultats de l'optimisation permet d'ouvrir automatiquement les résultats lorsque l'optimisation est terminée.
3. Le Strategy Tester reste maintenant en mode d'optimisation après le lancement d'un seul test. Dans les versions précédentes, si un test simple était lancé depuis l'onglet des résultats d'optimisation, le strategy tester basculait en mode de test simple. Le mode d'optimisation devait être réactivé dans les paramètres pour effectuer d'autres optimisations.
4. Les ensembles de paramètres d'entrée peuvent maintenant être sauvegardés comme paramètres du strategy tester local, et sont disponibles depuis le menu contextuel en plus des traditionnels fichiers .set.

   
   
   

   
   
5. Ajout des traductions de l'interface en mongol, hongrois, roumain et ourdou.
   

MetaEditor

1. Ajout de la possibilité de changer l'ordre des expressions espions dans la fenêtre du débogueur. Une expression peut être glissée avec la souris à la position désirée.
   

   
   
   

   
   
2. Correction de la détermination de l'encodage d'un fichier source.
3. Correction de la recherche dans les fichiers avec l'encodage en UTF-8.
4. Correction de la sélection de texte avec la souris si le texte contient des tabulations.
   
5. Ajout des traductions de l'interface en hongrois et en roumain.

Documentation mise à jour.

MQL5

1. Ajout de la fonction CopyTicksRange.
2. Ajout de fonctions d'anti-aliasing améliorées dans la classe CCanvas :
• CircleWu
• EllipseWu
• LineWu
• PolygonWu
• PolylineWu
• TriangleWu
3. Ajout de la description de la bibliothèque graphique dans la Référence MQL5. La bibliothèque permet de créer rapidement des histogrammes, des graphiques de distribution et des graphiques linéaires directement sur les graphiques des prix.
4. Ajout des identifiants d'état des touches du système dans la liste des constantes des Propriétés du Terminal Client. Un appel à TerminalInfoInteger(TERMINAL_KEYSTATE_XXX) retourne le même code d'état d'une touche que la fonction GetKeyState() dans MSDN.
5. Désactivation du support du cast d'une chaîne de caractères (string) en bool. Pour vérifier les chaînes de caractères, il faut maintenant utiliser des conditions explicites. Par exemple, avec le nouveau build, la compilation du code suivant déclenchera une erreur :
   

   string str;
   ...
   if(str)                        // erreur de compilation "Cannot convert type 'string' to 'bool'" (aucune erreur n'apparaissant dans les versions précédentes)
      Print("str est true");

   Il faut utiliser une condition explicite :
   

   string str;
   ...
   
   //--- vérifie si la chaîne est initialisée
   if(str!=NULL)
      Print("str est true");
   
   ou
   
   //--- vérifie si la chaîne vaut "true"
   if(StringCompare(str,"true",false))
      Print("str est true");
   
   ou
   
   //--- vérifie si la chaîne est un entier et n'est pas égal à zéro
   if((int)str!=0)
      Print("str est true");

Correction d'erreurs reportées dans les journaux de crash.

• Nous avons ajouté l'authentification à deux facteurs utilisant des mots de passe à usage unique, ce qui améliore la protection des comptes contre des accès non autorisés. Pour activer l'authentification à deux facteurs, lancez l'application mobile MetaTrader 5. Connectez-vous et choisissez le générateur OTP dans la fenêtre Paramètres. Le générateur de mot de passe à usage unique (One-time password - OTP) peut lier tous vos comptes de trading et génére automatiquement un mot de passe unique composé de 6 chiffres pour chaque compte. Saisissez le mot de passe généré lors de votre connexion à la plateforme web.

  
  
  
  

  
  
• Une autre nouvelle option permet de changer le mot de passe principal et le mot de passe investisseur. Profitez de cette opportunité pour créer un identifiant personnel façile à retenir.
• La plateforme web mise à jour peut maintenant aussi générer des comptes de démo. Vous pouvez maintenant lancer la plateforme web MetaTrader 5 depuis n'importe quel navigateur et commencer le trading du Forex, des Actions ou Futures immédiatement.

Terminal

Terminal

1. Ajout d'infobulles pour les boutons Buy, Sell et Close dans les boîtes de dialogue de trading. Les infobulles contiennent des informations sur l'instrument sur le point d'être acheté ou vendu, pour aider les débutants à comprendre le processus de trading.

   
   
   

   
   
2. Ajout de nouvelles icones pour les ordres, les transactions et les positions dans les onglets "Trading" et "Historique".

   
   
   

   
   
3. Le terminal mis à jour fournit un affichage et une mise à jour optimisés et bien plus rapides (jusqu'à 4 ou 5 fois) du Market Depth, du graphique des ticks et des données Time & Sales.
4. Correction de la synchronisation de l'historique des ticks en dehors des heures de trading. Le traitement pouvait consommer une quantité excessive du trafic réseau dans certains cas.

MQL5

1. Une version MQL5 de la bibliothèque d'analyse numérique ALGLIB a été inclue dans la Bibliothèque Standard.

   Fonctions de la Bibliothèque

   • Algèbre linéaire
   • Systèmes d'équations linéaires et non linéaires
   • Interpolation
   • Optimisation
   • Transformation de Fourier rapide
   • Intégration numérique
   • Moindres carrés linéaires et non linéaires
   • Equations différentielles ordinaires
   • Fonctions spéciales
   • Statistiques descriptives et tests d'hypothèses
   • Analyse des données - classification, régression
   • Implémentation des algorithmes d'algèbre linéaire, interpolation, etc. en arithmétique multi-précisions (utilisant MPFR)
     
     

   Comment l'Utiliser

   Les fichiers de ALGLIB sont situés dans \MQL5\Include\Math\Alglib. Pour utiliser les fonctions, incluez le fichier principal de la bibliothèques dans votre programme :

    #include <Math\Alglib\alglib.mqh> 

   
   

2. Des fonctions de statistiques mathématiques ont été inclues dans la Bibliothèque Standard. MQL5 fournit maintenant la fonctionnalité du langage R, qui est l'un des meilleurs outils pour le traitement et l'analyse de données statistiques.

   Fonctions de la Bibliothèque

   La bilbliothèque statistique contient des fonctions de calcul des caractéristiques statistiques des données, mais aussi des fonctions d'opérations avec les distributions statistiques :

   • Fonctions pour le calcul des caractéristiques statistiques des éléments d'un tableau
   • Options pour les opérations avec des distributions statistiques : distribution normale, distribution log-normale, distribution béta, etc.
     

   Comment l'Utiliser

   Les fichiers de la bilbiothèque statistique sont situés dans \MQL5\Include\Math\Stat. Pour utiliser cette bibliothèque, incluez dans votre programme les fichiers des fonctions désirées, par exemple :

   #include <Math\Stat\Binomal.mqh>
   #include <Math\Stat\Cauchy.mqh> 
   
   

   
   

   La description détaillée des fonctions de la bibliothèque est disponible dans l'article Distributions Statistiques en MQL5 - Profiter du Meilleur de R.

3. La version MQL5 de la bibliothèque Fuzzy a été inclue dans la Bibliothèque Standard. La bibliothèque Fuzzy implémente les systèmes d'inférence floue Mamdani et Sugeno.

   Fonctions de la Bibliothèque

   • 13 fonctions membres
   • Forme flexible de développement de règles du système flou
   • Système d'inférence Mamdani
   • Système d'inférence floue Sugeno
   • 5 méthode de défloutage pour les systèmes de type Mamdani
   • Quantité illimitée de variables d'entrée et de sortie
     
     

   Comment l'Utiliser

   Les fichiers de la bibliothèque Fuzzy sont situés dans \MQL5\Include\Math\Fuzzy. Pour utiliser cette bibliothèque, incluez dans votre programme les fichiers des fonctions désirées, par exemple :

   #include <Math\Fuzzy\mamdanifuzzysystem.mqh>
   #include <Math\Fuzzy\sugenofuzzysystem.mqh> 
   
   

   
   

   Une description détaillée des fonctions de la bibliothèque est disponible dans Code Base : Fuzzy - bibliothèque de développement des modèles flous

   
   
4. La nouvelle propriété CHART_QUICK_NAVIGATION permet d'activer/désactiver la barre de navigation rapide dans le graphique. Si vous avez besoin de modifier et d'accéder à l'état de la propriété, utilisez les fonctions ChartSetInteger et ChartGetInteger.

   
   
   
   

   La barre de navigation est ouverte en appuyant sur les touches Entrée ou Espace. Elle vous permet de vous déplacer rapidement à une date spécifiée sur le graphique, mais également de changer de symbole et de période. Si votre programme MQL5 utilise les touches Entrée ou Espace, désactiver la propriété CHART_QUICK_NAVIGATION pour éviter l'interception de ces évènements par le terminal. La barre de navigation rapide peut toujours être ouverte par un double-clic.
   
   
5. De nouvelles fonctions FileLoad et FileSave ont été ajoutées. Elles fournissent une méthode simplifiée de lecture et de sauvegarde des tableaux dans des fichiers. Contrairement ) FileRead* et FileWrite*, ces fonctions ne nécessitent pas le handle de l'indicateur. FileLoad et FileSave opèrent avec des tableaux d'élements de type numérique ou de structures simples qui ne contiennent pas de chaînes de caractères, de tableaux dynamiques ou de classes d'objets.
   

   long  FileLoad(
      const string filename,      // [in] Nom du fichier
      void         &buffer[],     // [out] Un tableau qui sera rempli par le fichier lu
      uint         common_flag=0  // [in] 0 - recherche du fichier dans le répertoire Files du terminal, FILE_COMMON - recherche dans le répertoire commun des terminaux
      );
   
   bool  FileSave(
      const string filename,      // [in] Nom du fichier
      const void   &buffer[],     // [in] Le tableau à sauvegarder dans un fichier
      uint         common_flag=0  // [in] 0 - crée un fichier dans le répertoire Files du terminal, FILE_COMMON - crée le fichier dans le répertoire commun des terminaux
      );
   
   

   Exemple d'écriture des ticks dans un fichier et de relecture du fichier :
   

   //--- paramètres d'entrée
   input int      ticks_to_save=1000; // Nombre de ticks
   //+------------------------------------------------------------------+
   //| Fonction de démarrage du programme                               |
   //+------------------------------------------------------------------+
   void OnStart()
     {
      string  filename=_Symbol+"_ticks.bin";
      MqlTick ticks[];
   //---
      int copied=CopyTicks(_Symbol,ticks,COPY_TICKS_ALL,0,ticks_to_save);
      if(copied!=-1)
        {
         PrintFormat(" CopyTicks(%s) a copié %d ticks",_Symbol,copied);
         //--- Si l'historique des ticks est synchronisé, le code d'erreur est égal à zéro
         if(!GetLastError()==0)
            PrintFormat("%s : les ticks ne sont pas synchronisés. Erreur=",_Symbol,copied,_LastError);
         //---  Ecriture des ticks dans un fichier
         if(!FileSave(filename,ticks,FILE_COMMON))
            PrintFormat("FileSave() a échoué, erreur=%d",GetLastError());
        }
      else
         PrintFormat("Echec de CopyTicks(%s), Erreur=",_Symbol,GetLastError());
   //--- Relecture des ticks depuis le fichier
      ArrayFree(ticks);
      long count=FileLoad(filename,ticks,FILE_COMMON);
      if(count!=-1)
        {
         Print("Time\tBid\tAsk\tLast\tVolume\tms\tflags");
         for(int i=0;i<count;i++)
           {
            PrintFormat("%s.%03I64u:\t%G\t%G\t%G\t%I64u\t0x%04x",
            TimeToString(ticks[i].time,TIME_DATE|TIME_SECONDS),ticks[i].time_msc%1000,
            ticks[i].bid,ticks[i].ask,ticks[i].last,ticks[i].volume,ticks[i].flags);
           }
        }
     }
   
   

   
   
6. Modification de l'affichage des indicateurs personnalisés avec le mode de dessin DRAW_CANDLES. Il est maintenant possible de définir de 1 à 3 couleurs pour ce mode. L'affichage des bougies dépends du nombre de couleurs défini.
   
   Si une couleur est spécifiée, toutes les bougies du graphiques seront intégralement peinte avec cette couleur.
   

   //--- Bougies dessinées avec la même couleur 
   #property indicator_label1  "Bougies à une couleur"
   #property indicator_type1   DRAW_CANDLES
   //--- Une seule couleur est spécifiée, donc toutes les bougies ont la même couleur
   #property indicator_color1  clrGreen  
   
   

   Si deux couleurs sont spécifiées, une couleur est utilisée pour les contours de la bougie, l'autre pour son corps.
   

   //--- La couleur des bougies diffère de la couleur des ombres
   #property indicator_label1  "Bougies à deux couleurs"
   #property indicator_type1   DRAW_CANDLES
   //--- Les contours des bougies et les ombres sont verts, le corps est blanc
   #property indicator_color1  clrGreen,clrWhite 
   
   

   Si trois couleurs sont spécifiées, une couleur est utilisée pour les contours de la bougie, les deux autres couleurs sont utilisées pour le corps des bougies montantes et descendantes.
   

   //--- La couleur des bougies diffère de la couleur des ombres
   #property indicator_label1  "Bougies à une couleur"
   #property indicator_type1   DRAW_CANDLES
   //--- Les contours des bougies et les ombres sont verts, le corps d'une bougie haussière est blanc, celui d'une bougie baissière est rouge
   #property indicator_color1  clrGreen,clrWhite,clrRed
   
   

   Le style DRAW_CANDLES permet de définir des couleurs personnalisées pour la bougie. Toutes les couleurs peuvent également être changées dynamiquement lorsque l'indicateur est en cours d'exécution, en utilisant la fonction PlotIndexSetInteger(drawing_index_DRAW_CANDLES, PLOT_LINE_COLOR, modifier_number, couleur) où modifier_number peut avoir les valeurs suivantes :
   
   • 0 – la couleur des bordures et des ombres
   • 1 – la couleur du corps d'une bougie haussière
   • 2 – la couleur du corps d'une bougie baissière
     

   //--- Définition de la couleur des bordures et des ombres
   PlotIndexSetInteger(0,PLOT_LINE_COLOR,0,clrBlue);
   //--- Définition de la couleur du corps d'une bougie haussière
   PlotIndexSetInteger(0,PLOT_LINE_COLOR,1,clrGreen);
   //--- Définition de la couleur du corps d'une bougie baissière
   PlotIndexSetInteger(0,PLOT_LINE_COLOR,2,clrRed);
   
   

7. Correction de bugs et utilisation améliorée de l'historique des ticks utilisant les fonctions CopyTicks.
8. Avec le nouveau build, les opérateurs peuvent être utilisés dans les interfaces (ce qui n'était pas permis auparavant).

Market

1. Correction d'une erreur qui pouvait provoquer une demande répétée de connexion à la MQL5.community lors de l'achat de produits sur le Market.
   

Tester

1. Ajout de la traduction de l'interface en grec, malais et hébreux.

Documentation mise à jour.

• Ajout de la possibilité de redimensionner les blocs de l'application web, incluant les fenêtres du Market Watch et du graphique des prix.
  
• Ajout de la possibilité de trier les colonnes dans les onglets Trade et Historique de la fenêtre Boîte à Outils. La largeur des colonnes peut être modifiée.
  
• Ajout de l'onglet Détails et de la possibilité d'ajouter rapidement un symbole.
  
• Amélioration globale de la vitesse d'exécution des opérations du terminal web grâce à l'optimisation du code. L'initialisation des comptes, l'ajout de symboles et le trading lui-même sont maintenant effectués encore plus rapidement.

Terminal

1. Implémentation du nouvel algorithme de calcul de l'onglet Exposition pour les marchés boursiers. La plateforme adapte dorénavant l'affichage des actifs suivant le système de gestion du risque appliqué au compte de trading : modèle Forex, Futures ou Boursier.
   
   La session Actifs est utile pour ceux tradant le Forex ou les futures en bourse affichant leur statut actuel sur le marché. Les mêmes devises peuvent être trouvées sous différents symboles : comme l'une des devises d'une paire, comme devise de base, etc. Par exemple, vous pouvez avoir des directions opposées sur les GBPUSD, USDJPY et GBPJY. Dans cette situation, il est très difficile de comprendre combien de devises vous détenez et de combien vous avez besoin. Avoir plus de trois positions complique encore plus la tâche. Dans ce cas, le statut total du compte est facilement disponible dans l'onglet Actifs.
   Utilisons les trois mêmes positions comme exemple :
   
   Buy GBPJPY 1 lot à 134.027 — reçus 100 000 GBP, donnés 134 027 000 JPY
   Sell USDJPY 1 lot à 102.320 — donnés 100 000 USD, reçus 102 320 000 JPY
   Sell GBPUSD 1 lot à 1.30923 — donnés 100 000 GBP, reçus 103 920 USD
   
   Nous avons acheté et vendu 100 000 GPB simultanément. Nous avons 0 GBP, et l'onglet Actifs n'affiche pas cette devise. Pour l'USD, nous en avons donné dans un cas et reçus dans un autre. L'onglet Actifs calcule le revenu final et l'ajoute au solde actuel puisque la devise du dépôt est également l'USD. Le JPY a participé dans deux transactions, l'onglet affiche donc sa valeur totale.
   

   
   
   

   
   Ceux utilisant le modèle boursier peuvent utiliser la section pour comprendre comment leur argent est utilisé. Contrairement au modèle précédent, les fonds sont retirés/ajoutés directement lorsque les transactions sont effectuées. Par exemple, si vous achetez de l'EURRUB, vous reçevez de l'EUR en une seule fois, tandis la somme appropriée en RUB est retirée du solde. Pendant le trading, le solde du compte peut même devenir négative : lorsque vous utilisez de l'argent emprunté alors que les actifs achetés sont utilisés comme collatéral. Dans ce cas, l'onglet Actifs vous permet de comprendre facilement le statut du compte de trading.
   
   Vous pouvez également voir la valeur de liquidation ici — le montant des fonds du compte et le prix (le résultat) de la clôture de toutes les positions actuelles au prix du marché.

   
   
   
   

   
   
2. Correction de l'affichage du type de la transaction dans l'historique des opérations de trading.
3. Correction de la répétition de l'affichage de la fenêtre de notification de risque lors de reconnexion à un compte de trading.
4. Correction et optimisation de l'utilisation de la fenêtre de sélection d'un symbole de trading dans le cas d'un grand nombre de symboles (plusieurs milliers et plus).
5. Correction de l'affichage des niveaux des indicateurs intégrés calculés sur la base d'une Moyenne Mobile (Bandes de Bollinger, Adaptive Moving Average, etc.). Auparavant, une erreur survenait lors du dessin des indicateurs dans une sous-fenêtre séparée.
6. Correction d'une erreur qui pouvait occasionnellement interférer avec le placement d'ordres sur des contrats de futures dans le cas où le prix de l'ordre coïncide avec la limite supérieure ou inférieure du prix du contrat.

MQL5

1. Compilation optimisée et accélerée des applications MQL5.
2. Ajout du support des modificateurs 'final' et 'override' pour les classes, les structures et les fonctions.
   
   Modificateur 'final' pour les classes et les structures
   La présence du modificateur 'final' dans la déclaration d'une structure ou d'une classe interdit tout héritage ultérieur. S'il n'y a pas besoin de faire des changements supplémentaires dans la classe (structure) ou si ces changements ne sont pas acceptables pour des raisons de sécurité, déclarez cette classe (structure) avec le modificateur 'final'. Dans ce cas, toutes les méthodes de la classe sont également considérée implicitement comme 'final'.
   

   class CFoo final
     {
     //--- corps de la classe
     };
    
   class CBar : public CFoo
     {
     //--- corps de la classe
     };

   Lors de la tentative d'héritage d'une classe ayant le modificateur 'final' comme ci-dessus, le compilateur affiche une erreur :
   cannot inherit from 'CFoo' as it has been declared as 'final'
   see declaration of 'CFoo'
   
   
   Modificateur 'override' pour les fonctions
   Le modificateur 'override' signifie qu'une fonction déclarée devrait toujours redéfinir la méthode de la classe parent. L'utilisation des modificateurs vous permet d'éviter des erreurs lors des spécialisations, telles qu'un changement de signature de la méthode. Par exemple, la méthode 'func' acceptant une variable de type 'int' est définie dans la classe de base :
   

   class CFoo
     {
      void virtual func(int x) const { }
     };

   La méthode est surchargée dans la classe héritée :
   

   class CBar : public CFoo
     {
      void func(short x) { }
     };

   Mais le type de l'argument est changé par erreur de 'int' en 'short'. En fait, la surcharge de la méthode au lieu de sa spécialisation est effectuée dans ce cas. Tout en se conformant à l'algorithme de surcharge de la définition d'une fonction, le compilateur peut dans certains cas sélectionner une méthode définie dans la classe de base au lieu de celle spécialisée.
   
   Pour éviter ce genre d'erreurs, le modificateur 'override' devrait être explicitement ajouté à la méthode spécialisée.
   

   class CBar : public CFoo
     {
      void func(short x) override { }
     };

   Si la signature de la méthode est changée pendant la spécialisation, le compilateur ne peut pas trouver la méthode de la classe parent ayant la même signature, provoquant l'erreur de compilation :
   'CBar::func' method is declared with 'override' specifier but does not override any base class method
   
   
   Modificateur 'final' pour les fonctions
   Le modificateur 'final' agit de la façon inverse — il empêche la spécialisation d'une méthode dans les classe dérivées. Si l'implémentation de la méthode est auto-suffisante et complète, déclarez-la avec le modificateur 'final' pour vous assurer qu'elle ne sera pas changée ultérieurement.
   

   class CFoo
     {
      void virtual func(int x) final { }
     };
    
   class CBar : public CFoo
     {
      void func(int) { }
     };
    

   Lors de la tentative de spécialisation d'une méthode ayant le modificateur 'final' comme ci-dessus, le compilateur affiche une erreur :
   'CFoo::func' method declared as 'final' cannot be overridden by 'CBar::func'
   see declaration of 'CFoo::func'
   
3. Correction de la compilation des fonctions template avec des paramètres par défaut.

Market

1. Correction de quelques erreurs dans le tri des produits du Market.
   

Tester

1. Correction de la mise à jour des prix actuels du marché pour les ordres et positions ouvertes dans le mode de test visuel.
   
2. Suppression du slippage pendant l'exécution des ordres Buy Limit et Sell Limit lors du test de symboles boursiers.
   
3. Correction de la génération occasionnelle de prix incorrects dans le mode de test "Prix d'ouverture".
4. Correction de la génération d'évènements OnTradeTransaction lors du test.
5. Lors d'un test basé sur les ticks réels, les données incorrectes des prix des ticks (bid ou last suivant le prix utilisé pour générer une barre) et les valeurs low et high de la barre de la minute existante apparaissent dans le journal du testeur.

MetaEditor

1. Correction de l'affichage du profilage des données dans les fichiers de code source.
   

Documentation mise à jour.

Terminal

1. Le terminal client prévoit désormais un envoi plus rapide des ordres de négociation.
2. Correction d'une erreur qui empêchait l'exécution des applications MQL5 sur les terminaux fonctionnant sous Windows 10 de 32-bit, build 1607.
3. Le navigateur affiche maintenant lorsque le compte de négociation fonctionne en mode de Couverture ou de Compensation.
4. Une nouvelle commande de menu contextuel a été ajoutée au navigateur, il vous permet de vous connecter à une borne Internet à l'aide d'un compte sélectionné.
5. La section Aide du menu a été mise à jour, et propose maintenant des liens vers des guides vidéo.
   
6. Correction des erreurs liées aux opérations sur affichage à haute résolution (4K)
7. Correction des erreurs en traduction perse de l'interface utilisateur.
   

MQL5

1. Ajout d'une indication vide* pour permettre aux utilisateurs de créer des collections abstraites d'objets. Une indication vers un objet de n'importe quelle classe peut être enregistrée à ce type de variable.
   Il est recommandé d'utiliser l'opérateur dynamic_cast<class name *>(indication vide *) afin de revenir en arrière. Si la conversion n'est pas possible, le résultat est NULL.
   

   class CFoo { };
   class CBar { };
   //+------------------------------------------------------------------+
   //| Script program start function                                    |
   //+------------------------------------------------------------------+
   void OnStart()
     {
      void *vptr[2];
      vptr[0]=new CFoo();
      vptr[1]=new CBar();
   //---
      for(int i=0;i<ArraySize(vptr);i++)
        {
         if(dynamic_cast<CFoo *>(vptr[i])!=NULL)
            Print("CFoo * object at index ",i);
         if(dynamic_cast<CBar *>(vptr[i])!=NULL)
            Print("CBar * object at index ",i);
        }
      CFoo *fptr=vptr[1];  // Will return an error while casting pointers, vptr[1] is not an object of CFoo
     }
   //+------------------------------------------------------------------+

   
   
2. Ajout du support pour l'opérateur [ ] pour libellés. L'opérateur permet aux utilisateurs de bénéficier d'un symbole à partir d'une chaîne par index. Si l'index spécifié est en dehors de la chaîne, le résultat est 0.
   

   String text="Bonjour"; ushort symb=texte[0];// retournera le code de symbole 'H'

3. Ajout d'une deuxième version du gestionnaire d'événements TesterInit avec la signature int OnTesterInit (vide), qui peut renvoyer INIT_SUCCEEDED (0) ou INIT_FAILED (ou toute valeur non nulle). Si OnTesterInit renvoie une valeur différente de zéro, l'optimisation ne commencera pas.
   
4. Correction d'une erreur qui pourrait aboutir à différents résultats renvoyés par les différents fonctions ChartGetString surchargées.
   

Testeur

1. Ajout de commandes supplémentaires et les touches de raccourci pour essai visuel. Maintenant il est possible de configurer des diagrammes dans le testeur visuel comme dans le terminal : changer les couleurs, contrôler la visibilité des différents éléments, appliquer des modèles, etc.
   

   
   
   

   
   
2. Correction de la fonction de mise en veille en mode de test « prix ouvert ».
3. Correction de la formation d’état incorrect des barres sur les échelles de temps W1 et MN1
   

MetaEditor

1. Traduction UI ajoutée en chinois traditionnel.
   

Mise à jour de la documentation.

Terminal

1. La fonctionnalité "Time & Sales" (Heures & Ventes) a été ajoutée au Market Depth.
   

   
   
   

   
   Qu'est-ce que Time & Sales ?
   La fonctionnalité Time & Sales fournit le prix et l'heure de chaque trade exécuté en bourse. Les informations sur chaque trade incluent l'heure à laquelle le trade a été exécuté, sa direction (achat ou vente), mais également son prix et son volume. Pour chaque analyse visuelle, différentes couleurs sont utilisées pour indiquer différentes directions : bleu pour les trades Buy, rose pour les trades Sell, vert signifie une direction indéfinie. Les volumes des trades sont également affichés sous forme d'histogramme.
   
   Comment Time & Sales peut vous aider à comprendre le marché
   La fonctionnalité Time & Sales fournit des outils pour une analyse plus détaillée du marché. La direction du trade suggère qui l'a initié : l'acheteur ou le vendeur. Le volume des trades permet aux traders de comprendre le comportement des participants du marché : les trades sont-ils effectués par des gros ou des petits joueurs, quelle est leur activité. La vitesse d'exécution du trade et le volume des trades sur différents niveaux de prix peuvent aider les traders à estimer l'importance des niveaux.
   
   Comment utiliser les données du Time & Sales
   En plus de l'analyse visuelle du tableau, vous pouvez sauvegarder les détails des trades dans un fichier CSV. Ils peuvent ensuite être analysés avec d'autres logiciels, tels que MS Excel. Le fichier contient les données suivantes séparées par des virgules :
   Time,Bid,Ask,Last,Volume,Type
   2016.07.06 16:05:04.305,89360,89370,89370,4,Buy
   2016.07.06 16:05:04.422,89360,89370,89370,2,Buy
   2016.07.06 16:05:04.422,89360,89370,89370,10,Buy
   2016.07.06 16:05:04.669,89360,89370,89370,1,Buy
   2016.07.06 16:05:05.968,89360,89370,89360,7,Sell
   
   Si vous souhaitez sauvegarder les données dans un fichier, ouvrez le menu contextuel :
   

   
   
   

   La plateforme du courtier doit être mise à jour avec la version 1365 pour activer la détection correcte de la direction des trades.
   
2. Le temps entre l'arrivée d'un nouveau tick/changement du Market depth et l'appel aux fonctions OnTick et OnCalculate a été réduit significativement. Le temps entre l'arrivée d'un évènement de changement d'état d'un trade et l'appel aux fonctions OnTick et OnCalculate a également été réduit. Les programmes MQL5 fournissent maintenant une réponse plus rapide aux évènements du marché.
3. Les demandes de trades sont maintenant envoyées plus rapidement lorsque l'authentification étendue avec les certificats SSL est utilisée.
4. La traduction de l'interface utilisateur en perse a été mise à jour.
5. Correction de l'affichage des commandes de fixation des SL/TP dans le menu contextuel du graphique lors de l'utilisation du mode de couverture.
   

Tester

1. Une nouvelle fonctionnalité du tester permet de demander l'historique des ticks pendant les tests utilisant la fonction CopyTicks. Dans les versions précédentes, l'accès aux ticks n'était pas disponible dans le Strategy Tester.
   
   
   • Dans le mode "Chaque tick", la fonction retournera l'historique des ticks générés. Il est possible de demander jusqu'aux 128.000 derniers ticks.
   • Dans le mode "Chaque tick basé sur les ticks réels", la fonction retournera l'historique des ticks réels. La profondeur des données demandées dépend de la disponibilité des données d'historique. Cependant, notez que les derniers 128.000 ticks sont mis en cache dans le Strategy Tester, et que la demande sera effectuée rapidement. Un historique plus profond est demandé depuis le disque dur, donc l'exécution de la demande peut prendre plus de temps.
     
   • La fonction ne fonctionnera pas dans les modes "Prix d'ouverture uniquement" et "1 minute OHLC", car l'historique des ticks n'est pas créé dans ces modes.
     
   
   
2. Ajout du support des millisecondes. Dans les versions précédentes, l'unité de base du temps dans le Strategy Tester était égal à une seconde.
   
   
   • Les fonctions EventSetMillisecondTimer et Sleep sont maintenant plus précises dans le Tester.
   • La précision de la livraison des ticks pendant le test d'un EA multi-devises a été augmentée. Dans les versions précédentes, si une seconde contenait plusieurs ticks (c'est à dire que le volume des ticks d'une barre 1 minute excédait 60), la même heure était mise pour tous ces ticks. Cela n'importe pas lors du test d'un Expert Advisor sur une seule devise, car les ticks sont passés séquentiellement à l'Expert Advisor. Cependant, lors du test d'un Expert Advisor sur plusieurs paires, il est important de connaître la paire pour laquelle le tick est arrivé le premier. Dans les versions précédentes, les ticks de chaque symbole étaient passés à l'Expert Advisor séquentiellement : en premier tous les ticks dans la seconde pour un symbole, puis tous les ticks pour l'autre symbole. Ils sont maintenant envoyés en prenant en compte les millisecondes.
     
     Lorsque les ticks réels sont utilisés pendant les tests, les millisecondes sont prises depuis les données source du tick. Lorsque les ticks sont générés, les millisecondes sont mises suivant le volume du tick. Par exemple, si 3 ticks tiennent dans une seconde, leurs nombres de millisecondes seront égaux à 000, 333 et 666.
     
   
   
3. Dans les modes "Prix d'ouverture uniquement" et "1 minute OHLC", les ordres en attentes et les ordres SL/TP sont maintenant exécutés au prix demandé et non pas au prix courant au moment de l'exécution. L'algorithme d'exécution au prix du marché utilisé dans les modes précis (chaque tick et ticks réels) ne convient pas pour les modes moins précis. Dans certains modes, les ticks intermédiaires ne sont pas générés, une différence entre le prix demandé dans l'ordre et le prix courant (Open ou OHLC) peut donc être significative. L'exécution des ordres aux prix demandés dans les modes "Prix d'ouverture uniquement" et "1 minute OHLC" fournissent des résultats de test plus précis.
   
   
4. Ajout du support du test avancé dans le mode visuel. Deux fenêtres distinctes sont maintenant ouvertes pour le test dans le passé et pour le test avancé, permettant aux utilisateurs de comparer les performances d'un Expert Advisor sur différents intervalles de temps.
   

   
   
   

   
   La fenêtre du test avancé n'est ouverte qu'une fois le test sur la période principale terminé.
   
   
5. La charge du dépôt est maintenant affichée dans le graphique principal du test au lieu du niveau de marge. La charge est calculée comme étant le rapport marge/fonds propres.
   

   
   

6. Tester : Correction du calcul des commissions comme un pourcentage annuel pendant le test.

MQL5

1. Le comportement de la fonction OrderSend pendant le placement, la modification ou l'annulation d'un ordre a changé. Le changement ne s'applique qu'aux ordres envoyés vers des systèmes de trading externes. Dans les versions précédentes, le contrôle de la fonction OrderSend était retourné une fois que l'ordre avait été placé avec succès (pris en compte) par le serveur du courtier. Le contrôle n'est maintenant retourné qu'une fois une notification venant d'un système de trading externe, informant que l'ordre y a été placé avec succès, est reçue.
   
   Le diagramme ci-dessous montre les comportements précédents (flèches rouges) et actuel de la fonction :
   

   
   
   

   
   
2. Un nouveau champ dans la structure MqlTradeResult : retcode_external - un code d'erreur dans le système de trading externe. L'utilisation et les types de ces erreurs dépendent du courtier du système externe de trading auquel les opérations de trading sont envoyées. Par exemple, les valeurs de retcode_external remplies par le Moscow Exchange sont différentes de celles de DGCX.
   
   
3. Nouvelles propriétés dans l'énumération ENUM_CHART_PROPERTY_STRING : CHART_EXPERT_NAME et CHART_SCRIPT_NAME. La fonction ChartGetString permet maintenant aux utilisateurs de trouver le nom d'un Expert Advisor et/ou d'un script attaché à un graphique défini par le paramètre chart_id.

Signaux

1. Correction d'erreurs occasionnelles en raison desquelles la copie d'une opération 'close by' pouvait échouer.
2. Amélioration de la correspondance automatique des paires de devises contenant RUB et RUR.

Market

1. Correction du tri par catégorie des produits.

MetaEditor

1. Correction de la mise en place du focus dans le champ du texte de remplacement lors de l'ouverture de la boîte de dialogue de remplacement.
2. Correction du remplacement de plusieurs occurences de texte lors de la recherche en arrière à partir de la position actuelle.