Михаил Филимонов (Все сообщения пользователя)

Добрый день!
Кто-нибудь знает почему покупая/продавая инструмент Si-12.20-3.21
в позициях появляются обычные фьючерсы Si-12.20 и Si-3.21?
Это же разные инструменты и стаканы у них разные.
Можно получить развернутый ответ?

unit tr2quik;

interface

uses
 WinApi.Windows, System.Sysutils, QTypes, WinApi.Messages;

//var
//  DllName: string;// = 'TRANS2QUIK.DLL';

const
 WM_ON_TRADE = WM_USER + 179;

//------------ Constants ------------
 TRANS2QUIK_UNKNOWN                   = -1;
 TRANS2QUIK_SUCCESS                   = 0;
 TRANS2QUIK_FAILED                    = 1;
 TRANS2QUIK_QUIK_TERMINAL_NOT_FOUND   = 2;
 TRANS2QUIK_DLL_VERSION_NOT_SUPPORTED = 3;
 TRANS2QUIK_ALREADY_CONNECTED_TO_QUIK = 4;
 TRANS2QUIK_WRONG_SYNTAX              = 5;
 TRANS2QUIK_QUIK_NOT_CONNECTED        = 6;
 TRANS2QUIK_DLL_NOT_CONNECTED         = 7;
 TRANS2QUIK_QUIK_CONNECTED            = 8;
 TRANS2QUIK_QUIK_DISCONNECTED         = 9;
 TRANS2QUIK_DLL_CONNECTED             = 10;
 TRANS2QUIK_DLL_DISCONNECTED          = 11;
 TRANS2QUIK_MEMORY_ALLOCATION_ERROR   = 12;
 TRANS2QUIK_WRONG_CONNECTION_HANDLE   = 13;
 TRANS2QUIK_WRONG_INPUT_PARAMS        = 14;

 ORDER_QUIKDATE          = 0;
 ORDER_QUIKTIME          = 1;
 ORDER_MICROSEC          = 2;
 ORDER_WITHDRAW_QUIKDATE = 3;
 ORDER_WITHDRAW_QUIKTIME = 4;
 ORDER_WITHDRAW_MICROSEC = 5;

 TRADE_QUIKDATE = 0;
 TRADE_QUIKTIME = 1;
 TRADE_MICROSEC = 2;

 REPL_NONE  = 0;
 REPL_TRANS = 1;
 REPL_ORDER = 2;
 REPL_TRADE = 3;

//--- DLL ERRORS ---
 TR2QUIK_TERMINAL_CLOSED      = 109;
 TR2QUIK_TRANSACTION_FAIL     = 233;
 TR2QUIK_NOT_SUBSCRIBE_ORDERS = $1000;
 TR2QUIK_NOT_SUBSCRIBE_TRADES = $1001;

//--------- Types ------
type
 intptr_t = NativeInt;
 Quantity = int64;
 EntityNumber = uint64;
 PEntityNumber = ^EntityNumber;
 OrderDescriptor = intptr_t;
 TradeDescriptor = intptr_t;
 TransReplyDescriptor = intptr_t;

//-------- Load library function -------
 function LibLoad(const aPath: string): THandle;

//--- CallBack procedures --------------
 procedure pfConnStatusCB(nConnectionEvent: long;
                          nExtendedErrorCode: long;
              lpcstrInfoMessage: LPCSTR); stdcall;

 procedure pfOrderStatusCB(nMode: long;
                           dwTransID: DWORD;
                           dNumber: EntityNumber;
                           ClassCode: LPCSTR;
                           SecCode: LPCSTR;
                           dPrice: double;
                           nBalance: Quantity;
                           dValue: double;
                           nIsSell: long;
                           nStatus: long;
                           ordDescr: OrderDescriptor); stdcall;

 procedure pfTradeStatusCB(nMode: long;
                           dNumber: EntityNumber;
                           dOrderNumber: EntityNumber;
                           ClassCode: LPCSTR;
                           SecCode: LPCSTR;
                           dPrice: double;
                           nQty: Quantity;
                           dValue: double;
                           nIsSell: long;
                           trDescriptor: TradeDescriptor); stdcall;

 procedure pfTransReplyCB(nTransactionResult: long;
                          nTransactionExtendedErrorCode: long;
                          nTransactionReplyCode: long;
                          dwTransId: DWord;
                          nOrderNum: EntityNumber;
                          lpcstrTransactionReplyMessage: LPCSTR;
                          trReplyDescr: TransReplyDescriptor); stdcall;

type
//----------------------- Prototype CallBack procedures ------------------
 TRANS2QUIK_CONNECTION_STATUS_CALLBACK = procedure(nConnectionEvent: long;
                                     nExtendedErrorCode: long;
                                       lpcstrInfoMessage: LPCSTR); stdcall;

 TRANS2QUIK_TRANSACTION_REPLY_CALLBACK = procedure(nTransactionResult: long;
                                     nTransactionExtendedErrorCode: long;
                                     nTransactionReplyCode: long;
                                     dwTransId: DWord;
                                       nOrderNum: EntityNumber;
                                     lpcstrTransactionReplyMessage: LPCSTR;
                                     trReplDesc: TransReplyDescriptor); stdcall;

 TRANS2QUIK_ORDER_STATUS_CALLBACK = procedure( nMode: long;
                                   dwTransID: DWORD;
                                 dNumber: EntityNumber;
                                 ClassCode: LPCSTR;
                                 SecCode: LPCSTR;
                                 dPrice: double;
                                 nBalance: Quantity;
                                 dValue: double;
                                 nIsSell: long;
                                 nStatus: long;
                                 orderDescriptor: OrderDescriptor); stdcall;

 TRANS2QUIK_TRADE_STATUS_CALLBACK = procedure( nMode: long;
                                 dNumber: EntityNumber;
                                 dOrderNumber: EntityNumber;
                                 ClassCode: LPCSTR;
                                 SecCode: LPCSTR;
                                 dPrice: double;
                                 nQty: Quantity;
                                 dValue: double;
                                 nIsSell: long;
                                 tradeDescriptor: TradeDescriptor); stdcall;
//------------ Functions -------------------
 TRANS2QUIK_SEND_SYNC_TRANSACTION = function(lpstTransactionString: LPSTR;
                                             var pnReplyCode: long;
                                             var pdwTransId: PDWORD;
                                             var pnOrderNum:EntityNumber;
                                             lpstrResultMessage: LPSTR;
                                             var dwResultMessageSize: DWORD;
                                             var pnExtendedErrorCode: long;
                                             lpstErrorMessage: LPSTR;
                                             var dwErrorMessageSize: DWORD): long; stdcall;
 TRANS2QUIK_SEND_ASYNC_TRANSACTION = function(lpstTransactionString: LPSTR;
                                              var pnExtendedErrorCode: long;
                                              lpstErrorMessage: LPSTR;
                                              var dwErrorMessageSize: DWORD): long; stdcall;
 TRANS2QUIK_CONNECT = function(lpstConnectionParamsString: LPSTR;
                               var pnExtendedErrorCode: long;
                               lpstrErrorMessage: LPSTR;
                               var dwErrorMessageSize: DWORD): long; stdcall;
 TRANS2QUIK_DISCONNECT = function(var pnExtendedErrorCode: long;
                                  lpstrErrorMessage: LPSTR;
                                  var dwErrorMessageSize: DWORD): long; stdcall;
 TRANS2QUIK_SET_CONNECTION_STATUS_CALLBACK = function(pfConnectionStatusCallback: TRANS2QUIK_CONNECTION_STATUS_CALLBACK;
                                                      var pnExtendedErrorCode: long;
                                                      lpstrErrorMessage: LPSTR;
                                                      var dwErrorMessageSize: DWORD): long; stdcall;
 TRANS2QUIK_SET_TRANSACTIONS_REPLY_CALLBACK = function(pfTransactionReplyCallback: TRANS2QUIK_TRANSACTION_REPLY_CALLBACK;
                                                       var pnExtendedErrorCode: long;
                                                       lpstrErrorMessage: LPSTR;
                                                       var dwErrorMessageSize: DWORD): long; stdcall;
 TRANS2QUIK_IS_QUIK_CONNECTED = function(var pnExtendedErrorCode: long;
                                         lpstrErrorMessage: LPSTR;
                                         var dwErrorMessageSize: Dword): long; stdcall;
 TRANS2QUIK_IS_DLL_CONNECTED = function(var pnExtendedErrorCode: long;
                                        lpstrErrorMessage: LPSTR;
                                        var dwErrorMessageSize: DWORD): long; stdcall;
//---
 TRANS2QUIK_SUBSCRIBE_ORDERS = function(ClassCode: LPSTR; Seccodes: LPSTR): long; stdcall;
 TRANS2QUIK_UNSUBSCRIBE_ORDERS = function(): long; stdcall;
 TRANS2QUIK_SUBSCRIBE_TRADES = function(ClassCode: LPSTR; Seccodes: LPSTR): long; stdcall;
 TRANS2QUIK_UNSUBSCRIBE_TRADES = function(): long;  stdcall;
//---
 TRANS2QUIK_START_TRADES = function(pfnTradeStatusCallback: TRANS2QUIK_TRADE_STATUS_CALLBACK): long; stdcall;
 TRANS2QUIK_START_ORDERS = function(pfnOrderStatusCallback: TRANS2QUIK_ORDER_STATUS_CALLBACK): long; stdcall;
//---
 TRANS2QUIK_ORDER_QTY = function(orderDescriptor: OrderDescriptor): Quantity; stdcall;
 TRANS2QUIK_ORDER_DATE = function(orderDescriptor: OrderDescriptor): long; stdcall;
 TRANS2QUIK_ORDER_TIME = function(orderDescriptor: OrderDescriptor): long; stdcall;
 TRANS2QUIK_ORDER_ACTIVATION_TIME = function(orderDescriptor: OrderDescriptor): long; stdcall;
 TRANS2QUIK_ORDER_WITHDRAW_TIME = function(orderDescriptor: OrderDescriptor): long; stdcall;
 TRANS2QUIK_ORDER_EXPIRY = function(orderDescriptor: OrderDescriptor): long; stdcall;
 TRANS2QUIK_ORDER_ACCRUED_INT = function(orderDescriptor: OrderDescriptor): Double; stdcall;
 TRANS2QUIK_ORDER_YIELD = function(orderDescriptor: OrderDescriptor): double; stdcall;
 TRANS2QUIK_ORDER_UID = function(orderDescriptor: OrderDescriptor): long; stdcall;
 TRANS2QUIK_ORDER_VISIBLE_QTY = function(orderDescriptor: OrderDescriptor): Quantity; stdcall;
 TRANS2QUIK_ORDER_PERIOD = function(orderDescriptor: OrderDescriptor): long; stdcall;
 TRANS2QUIK_ORDER_FILETIME = function(orderDescriptor: OrderDescriptor): FILETIME; stdcall;
 TRANS2QUIK_ORDER_DATE_TIME = function(orderDescriptor: OrderDescriptor; nTimeType: long): long; stdcall;
 TRANS2QUIK_ORDER_WITHDRAW_FILETIME = function(orderDescriptor: OrderDescriptor): FILETIME; stdcall;
 TRANS2QUIK_ORDER_VALUE_ENTRY_TYPE = function(orderDescriptor: OrderDescriptor): long; stdcall;
 TRANS2QUIK_ORDER_EXTENDED_FLAGS = function(orderDescriptor: OrderDescriptor): long; stdcall;
 TRANS2QUIK_ORDER_MIN_QTY = function(orderDescriptor: OrderDescriptor): Quantity; stdcall;
 TRANS2QUIK_ORDER_EXEC_TYPE = function(orderDescriptor: OrderDescriptor): long; stdcall;
 TRANS2QUIK_ORDER_AWG_PRICE = function(orderDescriptor: OrderDescriptor): double; stdcall;
 TRANS2QUIK_ORDER_USERID = function(orderDescriptor: OrderDescriptor): LPTSTR; stdcall;
 TRANS2QUIK_ORDER_ACCOUNT = function(orderDescriptor: OrderDescriptor): LPTSTR; stdcall;
 TRANS2QUIK_ORDER_BROKERREF = function(orderDescriptor: OrderDescriptor): LPTSTR; stdcall;
 TRANS2QUIK_ORDER_CLIENT_CODE = function(orderDescriptor: OrderDescriptor): LPTSTR; stdcall;
 TRANS2QUIK_ORDER_FIRMID = function(orderDescriptor: OrderDescriptor): LPTSTR; stdcall;
 TRANS2QUIK_ORDER_REJECT_REASON = function(orderDescriptor: OrderDescriptor): LPTSTR; stdcall;
//---
 TRANS2QUIK_TRADE_DATE = function(tradeDescriptor: TradeDescriptor): long; stdcall;
 TRANS2QUIK_TRADE_SETTLE_DATE = function(tradeDescriptor: TradeDescriptor): long; stdcall;
 TRANS2QUIK_TRADE_TIME = function(tradeDescriptor: TradeDescriptor): long; stdcall;
 TRANS2QUIK_TRADE_IS_MARGINAL = function(tradeDescriptor: TradeDescriptor): long; stdcall;
 TRANS2QUIK_TRADE_ACCRUED_INT = function(tradeDescriptor: TradeDescriptor): double; stdcall;
 TRANS2QUIK_TRADE_YIELD = function(tradeDescriptor: TradeDescriptor): double; stdcall;
 TRANS2QUIK_TRADE_TS_COMMISSION = function(tradeDescriptor: TradeDescriptor): double; stdcall;
 TRANS2QUIK_TRADE_CLEARING_CENTER_COMMISSION = function(tradeDescriptor: TradeDescriptor): double; stdcall;
 TRANS2QUIK_TRADE_EXCHANGE_COMMISSION = function(tradeDescriptor: TradeDescriptor): double; stdcall;
 TRANS2QUIK_TRADE_TRADING_SYSTEM_COMMISSION = function(tradeDescriptor: TradeDescriptor): double; stdcall;
 TRANS2QUIK_TRADE_PRICE2 = function(tradeDescriptor: TradeDescriptor): double; stdcall;
 TRANS2QUIK_TRADE_REPO_RATE = function(tradeDescriptor: TradeDescriptor): double; stdcall;
 TRANS2QUIK_TRADE_REPO_VALUE = function(tradeDescriptor: TradeDescriptor): double; stdcall;
 TRANS2QUIK_TRADE_REPO2_VALUE = function(tradeDescriptor: TradeDescriptor): double; stdcall;
 TRANS2QUIK_TRADE_ACCRUED_INT2 = function(tradeDescriptor: TradeDescriptor): double; stdcall;
 TRANS2QUIK_TRADE_REPO_TERM = function(tradeDescriptor: TradeDescriptor): long; stdcall;
 TRANS2QUIK_TRADE_START_DISCOUNT = function(tradeDescriptor: TradeDescriptor): double; stdcall;
 TRANS2QUIK_TRADE_LOWER_DISCOUNT = function(tradeDescriptor: TradeDescriptor): double; stdcall;
 TRANS2QUIK_TRADE_UPPER_DISCOUNT = function(tradeDescriptor: TradeDescriptor): double; stdcall;
 TRANS2QUIK_TRADE_BLOCK_SECURITIES = function(tradeDescriptor: TradeDescriptor): long; stdcall;
 TRANS2QUIK_TRADE_PERIOD = function(tradeDescriptor: TradeDescriptor): long; stdcall;
 TRANS2QUIK_TRADE_KIND = function(tradeDescriptor: TradeDescriptor): long; stdcall;
 TRANS2QUIK_TRADE_FILETIME = function(tradeDescriptor: TradeDescriptor): FILETIME; stdcall;
 TRANS2QUIK_TRADE_DATE_TIME = function(tradeDescriptor: TradeDescriptor; nTimeType: long): long; stdcall;
 TRANS2QUIK_TRADE_BROKER_COMMISSION = function(tradeDescriptor: TradeDescriptor): double; stdcall;
 TRANS2QUIK_TRADE_TRANSID = function(tradeDescriptor: TradeDescriptor): long; stdcall;
 TRANS2QUIK_TRADE_CURRENCY = function(tradeDescriptor: TradeDescriptor): LPTSTR; stdcall;
 TRANS2QUIK_TRADE_SETTLE_CURRENCY = function(tradeDescriptor: TradeDescriptor): LPTSTR; stdcall;
 TRANS2QUIK_TRADE_SETTLE_CODE = function(tradeDescriptor: TradeDescriptor): LPTSTR; stdcall;
 TRANS2QUIK_TRADE_ACCOUNT = function(tradeDescriptor: TradeDescriptor): LPTSTR; stdcall;
 TRANS2QUIK_TRADE_BROKERREF = function(tradeDescriptor: TradeDescriptor): LPTSTR; stdcall;
 TRANS2QUIK_TRADE_CLIENT_CODE = function(tradeDescriptor: TradeDescriptor): LPTSTR; stdcall;
 TRANS2QUIK_TRADE_USERID = function(tradeDescriptor: TradeDescriptor): LPTSTR; stdcall;
 TRANS2QUIK_TRADE_FIRMID = function(tradeDescriptor: TradeDescriptor): LPTSTR; stdcall;
 TRANS2QUIK_TRADE_PARTNER_FIRMID = function(tradeDescriptor: TradeDescriptor): LPTSTR; stdcall;
 TRANS2QUIK_TRADE_EXCHANGE_CODE = function(tradeDescriptor: TradeDescriptor): LPTSTR; stdcall;
 TRANS2QUIK_TRADE_STATION_ID = function(tradeDescriptor: TradeDescriptor): LPTSTR; stdcall;
//---
 TRANS2QUIK_TRANSACTION_REPLY_CLASS_CODE = function(TRD: TransReplyDescriptor): LPTSTR; stdcall;
 TRANS2QUIK_TRANSACTION_REPLY_SEC_CODE = function(TRD: TransReplyDescriptor): LPTSTR; stdcall;
 TRANS2QUIK_TRANSACTION_REPLY_PRICE = function(TRD: TransReplyDescriptor): double; stdcall;
 TRANS2QUIK_TRANSACTION_REPLY_QUANTITY = function(TRD: TransReplyDescriptor): Quantity; stdcall;
 TRANS2QUIK_TRANSACTION_REPLY_BALANCE = function(TRD: TransReplyDescriptor): Quantity; stdcall;
 TRANS2QUIK_TRANSACTION_REPLY_FIRMID = function(TRD: TransReplyDescriptor): LPTSTR; stdcall;
 TRANS2QUIK_TRANSACTION_REPLY_ACCOUNT = function(TRD: TransReplyDescriptor): LPTSTR; stdcall;
 TRANS2QUIK_TRANSACTION_REPLY_CLIENT_CODE = function(TRD: TransReplyDescriptor): LPTSTR; stdcall;
 TRANS2QUIK_TRANSACTION_REPLY_BROKERREF = function(TRD: TransReplyDescriptor): LPTSTR; stdcall;
 TRANS2QUIK_TRANSACTION_REPLY_EXCHANGE_CODE = function(TRD: TransReplyDescriptor): LPTSTR; stdcall;

var
 T2QSendSyncTrans: TRANS2QUIK_SEND_SYNC_TRANSACTION;
 T2QSendASyncTrans: TRANS2QUIK_SEND_ASYNC_TRANSACTION;
 T2QConnect: TRANS2QUIK_CONNECT;
 T2QDisconnect: TRANS2QUIK_DISCONNECT;
 T2QSetConnStatCB: TRANS2QUIK_SET_CONNECTION_STATUS_CALLBACK;
 T2QSetTransReplyCB: TRANS2QUIK_SET_TRANSACTIONS_REPLY_CALLBACK;
 T2QIsQuikConnected: TRANS2QUIK_IS_QUIK_CONNECTED;
 T2QIsDllConnected: TRANS2QUIK_IS_DLL_CONNECTED;
 T2QSubscribeOrders: TRANS2QUIK_SUBSCRIBE_ORDERS;
 T2QUnSubscribeOrders: TRANS2QUIK_UNSUBSCRIBE_ORDERS;
 T2QStartOrders: TRANS2QUIK_START_ORDERS;
 T2QOrderQty: TRANS2QUIK_ORDER_QTY;
 T2QOrderDate: TRANS2QUIK_ORDER_DATE;
 T2QOrderTime: TRANS2QUIK_ORDER_TIME;
 T2QOrderActiveTime: TRANS2QUIK_ORDER_ACTIVATION_TIME;
 T2QOrderWithdrawTime: TRANS2QUIK_ORDER_WITHDRAW_TIME;
 T2QOrderExpiry: TRANS2QUIK_ORDER_EXPIRY;
 T2QOrderAccruedInt: TRANS2QUIK_ORDER_ACCRUED_INT;
 T2QOrderYield: TRANS2QUIK_ORDER_YIELD;
 T2QOrderUid: TRANS2QUIK_ORDER_UID;
 T2QOrderVisibleQty: TRANS2QUIK_ORDER_VISIBLE_QTY;
 T2QOrderPeriod: TRANS2QUIK_ORDER_PERIOD;
 T2QOrderFileTime: TRANS2QUIK_ORDER_FILETIME;
 T2QOrderDateTime: TRANS2QUIK_ORDER_DATE_TIME;
 T2QOrderWithdrawFileTime: TRANS2QUIK_ORDER_WITHDRAW_FILETIME;
 T2QOrderValueEntryType: TRANS2QUIK_ORDER_VALUE_ENTRY_TYPE;
 T2QOrderExtdFlags: TRANS2QUIK_ORDER_EXTENDED_FLAGS;
 T2QOrderMinQty: TRANS2QUIK_ORDER_MIN_QTY;
 T2QOrderExecType: TRANS2QUIK_ORDER_EXEC_TYPE;
 T2QOrderAwgPrice: TRANS2QUIK_ORDER_AWG_PRICE;
 T2QOrderUserId: TRANS2QUIK_ORDER_USERID;
 T2QOrderAccaunt: TRANS2QUIK_ORDER_ACCOUNT;
 T2QOrderBrokerRef: TRANS2QUIK_ORDER_BROKERREF;
 T2QOrderClientCode: TRANS2QUIK_ORDER_CLIENT_CODE;
 T2QOrderFirmId: TRANS2QUIK_ORDER_FIRMID;
 T2QOrderRejectReason: TRANS2QUIK_ORDER_REJECT_REASON;
 T2QSubscribeTrades: TRANS2QUIK_SUBSCRIBE_TRADES;
 T2QUnSubscribeTrades: TRANS2QUIK_UNSUBSCRIBE_TRADES;
 T2QStartTrades: TRANS2QUIK_START_TRADES;
 T2QTradeDate: TRANS2QUIK_TRADE_DATE;
 T2QTradeSettleDate: TRANS2QUIK_TRADE_SETTLE_DATE;
 T2QTradeTime: TRANS2QUIK_TRADE_TIME;
 T2QTradeIsMarginal: TRANS2QUIK_TRADE_IS_MARGINAL;
 T2QTradeAccruedInt: TRANS2QUIK_TRADE_ACCRUED_INT;
 T2QTradeYield: TRANS2QUIK_TRADE_YIELD;
 T2QTradeTSCommission: TRANS2QUIK_TRADE_TS_COMMISSION;
 T2QTradeClCenterCommission: TRANS2QUIK_TRADE_CLEARING_CENTER_COMMISSION;
 T2QTradeExcCommission: TRANS2QUIK_TRADE_EXCHANGE_COMMISSION;
 T2QTradeTrSysCommission: TRANS2QUIK_TRADE_TRADING_SYSTEM_COMMISSION;
 T2QTradePrice2: TRANS2QUIK_TRADE_PRICE2;
 T2QTradeRepoRate: TRANS2QUIK_TRADE_REPO_RATE;
 T2QTradeRepoValue: TRANS2QUIK_TRADE_REPO_VALUE;
 T2QTradeRepo2Value: TRANS2QUIK_TRADE_REPO2_VALUE;
 T2QTradeAccruedInt2: TRANS2QUIK_TRADE_ACCRUED_INT2;
 T2QTradeRepoTerm: TRANS2QUIK_TRADE_REPO_TERM;
 T2QTradeStDiscount: TRANS2QUIK_TRADE_START_DISCOUNT;
 T2QTradeLwDiscount: TRANS2QUIK_TRADE_LOWER_DISCOUNT;
 T2QTradeUpDiscount: TRANS2QUIK_TRADE_UPPER_DISCOUNT;
 T2QTradeBlSecur: TRANS2QUIK_TRADE_BLOCK_SECURITIES;
 T2QTradePeriod: TRANS2QUIK_TRADE_PERIOD;
 T2QTradeKind: TRANS2QUIK_TRADE_KIND;
 T2QTradeFileName: TRANS2QUIK_TRADE_FILETIME;
 T2QTradeDateTime: TRANS2QUIK_TRADE_DATE_TIME;
 T2QTradeBrCommission: TRANS2QUIK_TRADE_BROKER_COMMISSION;
 T2QTradeTransId: TRANS2QUIK_TRADE_TRANSID;
 T2QTradeCurrensy: TRANS2QUIK_TRADE_CURRENCY;
 T2QTradeSettlCurr: TRANS2QUIK_TRADE_SETTLE_CURRENCY;
 T2QTradeSettlCode: TRANS2QUIK_TRADE_SETTLE_CODE;
 T2QTradeAccount: TRANS2QUIK_TRADE_ACCOUNT;
 T2QTradeBrRef: TRANS2QUIK_TRADE_BROKERREF;
 T2QTradeClCode: TRANS2QUIK_TRADE_CLIENT_CODE;
 T2QTradeUserId: TRANS2QUIK_TRADE_USERID;
 T2QTradeFirmId: TRANS2QUIK_TRADE_FIRMID;
 T2QTradePartFirmId: TRANS2QUIK_TRADE_PARTNER_FIRMID;
 T2QTradeExcCode: TRANS2QUIK_TRADE_EXCHANGE_CODE;
 T2QTradeStationId: TRANS2QUIK_TRADE_STATION_ID;
 T2QTransReplyClassCode: TRANS2QUIK_TRANSACTION_REPLY_CLASS_CODE;
 T2QTransReplySecCode: TRANS2QUIK_TRANSACTION_REPLY_SEC_CODE;
 T2QTransReplyPrice: TRANS2QUIK_TRANSACTION_REPLY_PRICE;
 T2QTransReplyQty: TRANS2QUIK_TRANSACTION_REPLY_QUANTITY;
 T2QTransReplyBal: TRANS2QUIK_TRANSACTION_REPLY_BALANCE;
 T2QTransReplyFirmId: TRANS2QUIK_TRANSACTION_REPLY_FIRMID;
 T2QTransReplyAccount: TRANS2QUIK_TRANSACTION_REPLY_ACCOUNT;
 T2QTransReplyClCode: TRANS2QUIK_TRANSACTION_REPLY_CLIENT_CODE;
 T2QTransReplyBrRef: TRANS2QUIK_TRANSACTION_REPLY_BROKERREF;
 T2QTransReplyExcCode: TRANS2QUIK_TRANSACTION_REPLY_EXCHANGE_CODE;

implementation
 uses Main, CHILDWIN;

function LibLoad(const aPath: string): THandle;
begin
 Result:= LoadLibrary(PWideChar(IncludeTrailingPathDelimiter(aPath) + MainData.DllName));
 if(Result > 0) then
 begin
   @T2QSendSyncTrans := GetProcAddress(Result, PWideChar('TRANS2QUIK_SEND_SYNC_TRANSACTION'));
   if(addr(T2QSendSyncTrans) = nil) then
   begin
      Result:= 0;
      Exit;
   end;
   @T2QSendASyncTrans := GetProcAddress(Result, PWideChar('TRANS2QUIK_SEND_ASYNC_TRANSACTION'));
   if(addr(T2QSendASyncTrans) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QConnect:= GetProcAddress(Result, PWideChar('TRANS2QUIK_CONNECT'));
   if(addr(T2QConnect) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QDisconnect := GetProcAddress(Result, PWideChar('TRANS2QUIK_DISCONNECT'));
   if(addr(T2QDisconnect) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QSetConnStatCB := GetProcAddress(Result, PWideChar('TRANS2QUIK_SET_CONNECTION_STATUS_CALLBACK'));
   if(addr(T2QSetConnStatCB) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QSetTransReplyCB := GetProcAddress(Result, PWideChar('TRANS2QUIK_SET_TRANSACTIONS_REPLY_CALLBACK'));
   if(addr(T2QSetTransReplyCB) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   //-----------
   //  ????????????????????????????
   //------------
   @T2QIsQuikConnected := GetProcAddress(Result, PWideChar('TRANS2QUIK_IS_QUIK_CONNECTED'));
   if(addr(T2QIsQuikConnected) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QIsDllConnected := GetProcAddress(Result, PWideChar('TRANS2QUIK_IS_DLL_CONNECTED'));
   if(addr(T2QIsDllConnected) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QSubscribeOrders := GetProcAddress(Result, PWideChar('TRANS2QUIK_SUBSCRIBE_ORDERS'));
   if(addr(T2QSubscribeOrders) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QUnSubscribeOrders := GetProcAddress(Result, PWideChar('TRANS2QUIK_UNSUBSCRIBE_ORDERS'));
   if(addr(T2QUnSubscribeOrders) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QStartOrders := GetProcAddress(Result, PWideChar('TRANS2QUIK_START_ORDERS'));
   if(addr(T2QStartOrders) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QOrderQty := GetProcAddress(Result, PWideChar('TRANS2QUIK_ORDER_QTY'));
   if(addr(T2QOrderQty) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QOrderDate := GetProcAddress(Result, PWideChar('TRANS2QUIK_ORDER_DATE'));
   if(addr(T2QOrderDate) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QOrderTime := GetProcAddress(Result, PWideChar('TRANS2QUIK_ORDER_TIME'));
   if(addr(T2QOrderTime) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QOrderActiveTime := GetProcAddress(Result, PWideChar('TRANS2QUIK_ORDER_ACTIVATION_TIME'));
   if(addr(T2QOrderActiveTime) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QOrderWithdrawTime := GetProcAddress(Result, PWideChar('TRANS2QUIK_ORDER_WITHDRAW_TIME'));
   if(addr(T2QOrderWithdrawTime) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QOrderExpiry := GetProcAddress(Result, PWideChar('TRANS2QUIK_ORDER_EXPIRY'));
   if(addr(T2QOrderExpiry) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QOrderAccruedInt := GetProcAddress(Result, PWideChar('TRANS2QUIK_ORDER_ACCRUED_INT'));
   if(addr(T2QOrderAccruedInt) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QOrderYield := GetProcAddress(Result, PWideChar('TRANS2QUIK_ORDER_YIELD'));
   if(addr(T2QOrderYield) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QOrderUid := GetProcAddress(Result, PWideChar('TRANS2QUIK_ORDER_UID'));
   if(addr(T2QOrderUid) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QOrderVisibleQty := GetProcAddress(Result, PWideChar('TRANS2QUIK_ORDER_VISIBLE_QTY'));
   if(addr(T2QOrderVisibleQty) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QOrderPeriod := GetProcAddress(Result, PWideChar('TRANS2QUIK_ORDER_PERIOD'));
   if(addr(T2QOrderPeriod) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QOrderFileTime := GetProcAddress(Result, PWideChar('TRANS2QUIK_ORDER_FILETIME'));
   if(addr(T2QOrderFileTime) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QOrderDateTime := GetProcAddress(Result, PWideChar('TRANS2QUIK_ORDER_DATE_TIME'));
   if(addr(T2QOrderDateTime) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QOrderWithdrawFileTime := GetProcAddress(Result, PWideChar('TRANS2QUIK_ORDER_WITHDRAW_FILETIME'));
   if(addr(T2QOrderWithdrawFileTime) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QOrderValueEntryType := GetProcAddress(Result, PWideChar('TRANS2QUIK_ORDER_VALUE_ENTRY_TYPE'));
   if(addr(T2QOrderValueEntryType) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QOrderExtdFlags := GetProcAddress(Result, PWideChar('TRANS2QUIK_ORDER_EXTENDED_FLAGS'));
   if(addr(T2QOrderExtdFlags) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QOrderMinQty := GetProcAddress(Result, PWideChar('TRANS2QUIK_ORDER_MIN_QTY'));
   if(addr(T2QOrderMinQty) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QOrderExecType := GetProcAddress(Result, PWideChar('TRANS2QUIK_ORDER_EXEC_TYPE'));
   if(addr(T2QOrderExecType) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QOrderAwgPrice := GetProcAddress(Result, PWideChar('TRANS2QUIK_ORDER_AWG_PRICE'));
   if(addr(T2QOrderAwgPrice) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QOrderUserId := GetProcAddress(Result, PWideChar('TRANS2QUIK_ORDER_USERID'));
   if(addr(T2QOrderUserId) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QOrderAccaunt := GetProcAddress(Result, PWideChar('TRANS2QUIK_ORDER_ACCOUNT'));
   if(addr(T2QOrderAccaunt) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QOrderBrokerRef := GetProcAddress(Result, PWideChar('TRANS2QUIK_ORDER_BROKERREF'));
   if(addr(T2QOrderBrokerRef) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QOrderClientCode := GetProcAddress(Result, PWideChar('TRANS2QUIK_ORDER_CLIENT_CODE'));
   if(addr(T2QOrderClientCode) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QOrderFirmId := GetProcAddress(Result, PWideChar('TRANS2QUIK_ORDER_FIRMID'));
   if(addr(T2QOrderFirmId) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QOrderRejectReason := GetProcAddress(Result, PWideChar('TRANS2QUIK_ORDER_REJECT_REASON'));
   if(addr(T2QOrderRejectReason) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QSubscribeTrades := GetProcAddress(Result, PWideChar('TRANS2QUIK_SUBSCRIBE_TRADES'));
   if(addr(T2QSubscribeTrades) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QUnSubscribeTrades := GetProcAddress(Result, PWideChar('TRANS2QUIK_UNSUBSCRIBE_TRADES'));
   if(addr(T2QUnSubscribeTrades) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QStartTrades := GetProcAddress(Result, PWideChar('TRANS2QUIK_START_TRADES'));
   if(addr(T2QStartTrades) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QTradeDate := GetProcAddress(Result, PWideChar('TRANS2QUIK_TRADE_DATE'));
   if(addr(T2QTradeDate) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QTradeSettleDate := GetProcAddress(Result, PWideChar('TRANS2QUIK_TRADE_SETTLE_DATE'));
   if(addr(T2QTradeSettleDate) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QTradeTime := GetProcAddress(Result, PWideChar('TRANS2QUIK_TRADE_TIME'));
   if(addr(T2QTradeTime) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QTradeIsMarginal := GetProcAddress(Result, PWideChar('TRANS2QUIK_TRADE_IS_MARGINAL'));
   if(addr(T2QTradeIsMarginal) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QTradeAccruedInt := GetProcAddress(Result, PWideChar('TRANS2QUIK_TRADE_ACCRUED_INT'));
   if(addr(T2QTradeAccruedInt) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QTradeYield := GetProcAddress(Result, PWideChar('TRANS2QUIK_TRADE_YIELD'));
   if(addr(T2QTradeYield) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QTradeTSCommission := GetProcAddress(Result, PWideChar('TRANS2QUIK_TRADE_TS_COMMISSION'));
   if(addr(T2QTradeTSCommission) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QTradeClCenterCommission := GetProcAddress(Result, PWideChar('TRANS2QUIK_TRADE_TS_COMMISSION'));
   if(addr(T2QTradeClCenterCommission) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QTradeExcCommission := GetProcAddress(Result, PWideChar('TRANS2QUIK_TRADE_EXCHANGE_COMMISSION'));
   if(addr(T2QTradeExcCommission) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QTradeTrSysCommission := GetProcAddress(Result, PWideChar('TRANS2QUIK_TRADE_TRADING_SYSTEM_COMMISSION'));
   if(addr(T2QTradeTrSysCommission) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QTradePrice2 := GetProcAddress(Result, PWideChar('TRANS2QUIK_TRADE_PRICE2'));
   if(addr(T2QTradePrice2) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QTradeRepoRate := GetProcAddress(Result, PWideChar('TRANS2QUIK_TRADE_REPO_RATE'));
   if(addr(T2QTradeRepoRate) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QTradeRepoValue := GetProcAddress(Result, PWideChar('TRANS2QUIK_TRADE_REPO_VALUE'));
   if(addr(T2QTradeRepoValue) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QTradeRepo2Value := GetProcAddress(Result, PWideChar('TRANS2QUIK_TRADE_REPO2_VALUE'));
   if(addr(T2QTradeRepo2Value) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QTradeAccruedInt2 := GetProcAddress(Result, PWideChar('TRANS2QUIK_TRADE_ACCRUED_INT2'));
   if(addr(T2QTradeAccruedInt2) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QTradeRepoTerm := GetProcAddress(Result, PWideChar('TRANS2QUIK_TRADE_REPO_TERM'));
   if(addr(T2QTradeRepoTerm) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QTradeStDiscount := GetProcAddress(Result, PWideChar('TRANS2QUIK_TRADE_START_DISCOUNT'));
   if(addr(T2QTradeStDiscount) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QTradeLwDiscount := GetProcAddress(Result, PWideChar('TRANS2QUIK_TRADE_LOWER_DISCOUNT'));
   if(addr(T2QTradeLwDiscount) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QTradeUpDiscount := GetProcAddress(Result, PWideChar('TRANS2QUIK_TRADE_UPPER_DISCOUNT'));
   if(addr(T2QTradeUpDiscount) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QTradeBlSecur := GetProcAddress(Result, PWideChar('TRANS2QUIK_TRADE_UPPER_DISCOUNT'));
   if(addr(T2QTradeBlSecur) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QTradePeriod := GetProcAddress(Result, PWideChar('TRANS2QUIK_TRADE_PERIOD'));
   if(addr(T2QTradePeriod) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QTradeKind := GetProcAddress(Result, PWideChar('TRANS2QUIK_TRADE_KIND'));
   if(addr(T2QTradeKind) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QTradeFileName := GetProcAddress(Result, PWideChar('TRANS2QUIK_TRADE_FILETIME'));
   if(addr(T2QTradeFileName) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QTradeDateTime := GetProcAddress(Result, PWideChar('TRANS2QUIK_TRADE_DATE_TIME'));
   if(addr(T2QTradeDateTime) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QTradeBrCommission := GetProcAddress(Result, PWideChar('TRANS2QUIK_TRADE_BROKER_COMMISSION'));
   if(addr(T2QTradeBrCommission) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QTradeTransId := GetProcAddress(Result, PWideChar('TRANS2QUIK_TRADE_TRANSID'));
   if(addr(T2QTradeTransId) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QTradeCurrensy := GetProcAddress(Result, PWideChar('TRANS2QUIK_TRADE_CURRENCY'));
   if(addr(T2QTradeCurrensy) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QTradeSettlCurr := GetProcAddress(Result, PWideChar('TRANS2QUIK_TRADE_SETTLE_CURRENCY'));
   if(addr(T2QTradeSettlCurr) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QTradeSettlCode := GetProcAddress(Result, PWideChar('TRANS2QUIK_TRADE_SETTLE_CODE'));
   if(addr(T2QTradeSettlCode) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QTradeAccount := GetProcAddress(Result, PWideChar('TRANS2QUIK_TRADE_ACCOUNT'));
   if(addr(T2QTradeAccount) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QTradeBrRef := GetProcAddress(Result, PWideChar('TRANS2QUIK_TRADE_BROKERREF'));
   if(addr(T2QTradeBrRef) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QTradeClCode := GetProcAddress(Result, PWideChar('TRANS2QUIK_TRADE_CLIENT_CODE'));
   if(addr(T2QTradeClCode) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QTradeUserId := GetProcAddress(Result, PWideChar('TRANS2QUIK_TRADE_USERID'));
   if(addr(T2QTradeUserId) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QTradeFirmId := GetProcAddress(Result, PWideChar('TRANS2QUIK_TRADE_FIRMID'));
   if(addr(T2QTradeFirmId) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QTradePartFirmId := GetProcAddress(Result, PWideChar('TRANS2QUIK_TRADE_PARTNER_FIRMID'));
   if(addr(T2QTradePartFirmId) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QTradeExcCode := GetProcAddress(Result, PWideChar('TRANS2QUIK_TRADE_EXCHANGE_CODE'));
   if(addr(T2QTradeExcCode) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QTradeStationId := GetProcAddress(Result, PWideChar('TRANS2QUIK_TRADE_STATION_ID'));
   if(addr(T2QTradeStationId) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QTransReplyClassCode := GetProcAddress(Result, PWideChar('TRANS2QUIK_TRANSACTION_REPLY_CLASS_CODE'));
   if(addr(T2QTransReplyClassCode) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QTransReplySecCode := GetProcAddress(Result, PWideChar('TRANS2QUIK_TRANSACTION_REPLY_SEC_CODE'));
   if(addr(T2QTransReplySecCode) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QTransReplyPrice := GetProcAddress(Result, PWideChar('TRANS2QUIK_TRANSACTION_REPLY_PRICE'));
   if(addr(T2QTransReplyPrice) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QTransReplyQty := GetProcAddress(Result, PWideChar('TRANS2QUIK_TRANSACTION_REPLY_QUANTITY'));
   if(addr(T2QTransReplyQty) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QTransReplyBal := GetProcAddress(Result, PWideChar('TRANS2QUIK_TRANSACTION_REPLY_BALANCE'));
   if(addr(T2QTransReplyBal) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QTransReplyFirmId := GetProcAddress(Result, PWideChar('TRANS2QUIK_TRANSACTION_REPLY_FIRMID'));
   if(addr(T2QTransReplyFirmId) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QTransReplyAccount := GetProcAddress(Result, PWideChar('TRANS2QUIK_TRANSACTION_REPLY_ACCOUNT'));
   if(addr(T2QTransReplyAccount) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QTransReplyClCode := GetProcAddress(Result, PWideChar('TRANS2QUIK_TRANSACTION_REPLY_CLIENT_CODE'));
   if(addr(T2QTransReplyClCode) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QTransReplyBrRef := GetProcAddress(Result, PWideChar('TRANS2QUIK_TRANSACTION_REPLY_BROKERREF'));
   if(addr(T2QTransReplyBrRef) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
   @T2QTransReplyExcCode := GetProcAddress(Result, PWideChar('TRANS2QUIK_TRANSACTION_REPLY_EXCHANGE_CODE'));
   if(addr(T2QTransReplyExcCode) = nil) then
   begin
     Result:= 0;
     Exit;
   end;
 end;
end;

//--- Connection status Call Back ---------
procedure pfConnStatusCB;
begin
 //
end;

//--- Transaction callback -----
procedure pfTransReplyCB;
begin
  //
end;

//--- Order status callback -----
procedure pfOrderStatusCB;
begin
 //
end;

//--- Trade status callback -----
procedure pfTradeStatusCB;
begin
 //
end;

end.

Это технический форум, а не рекламная доска!
Хотите помочь - пишите здесь.
Странно, что модераторы оставили это сообщение.

Ну почему же никто?
Отправка ассинхронного ордера


procedure TExpert.OnTrade;
var
 outStr, id: string;
 res: long;
 ErrCode: long;
 ErrSize: Dword;
 ErrStr: LPSTR;
 Dt: TDateTime;
begin
 FOrder:= 0;
 FTransID:= GetTransID();
 id:= IntToStr(TransID);
 FMustSpotVol:= (Volume * ExpData.FutData.Lot)/ExpData.SpotData.Lot; //Get spot volume
 case aSell of
   0: begin                            //Buy trade, sell spot (output position)
     outStr:= 'ACCOUNT=' + ExpData.SpotAccaunt + '; CLIENT_CODE=' +
              ExpData.Client + '; TYPE=L; TRANS_ID=' + id + '; CLASSCODE=' +
              ExpData.SpotData.ClassCode + '; SECCODE=' + ExpData.SpotData.SecCode +
              '; ACTION=NEW_ORDER; OPERATION=S' + '; PRICE=' +
              FloatToStr(ExpData.SpotData.BuyPrice - 10 * ExpData.SpotData.Step) +
              '; QUANTITY=' + FloatToStr(MustSpotVol) + ';';
   end;
   else begin
     outStr:= 'ACCOUNT=' + ExpData.SpotAccaunt + '; CLIENT_CODE=' +
              ExpData.Client + '; TYPE=L; TRANS_ID=' + id +
              '; CLASSCODE=' + ExpData.SpotData.ClassCode + '; SECCODE=' +
              ExpData.SpotData.SecCode +
              '; ACTION=NEW_ORDER; OPERATION=B' + '; PRICE=' +
              FloatToStr(ExpData.SpotData.SellPrice + 10 * ExpData.SpotData.Step) +
              '; QUANTITY=' + FloatToStr(MustSpotVol) + ';';
   end;
 end;
 ErrCode:= 0;
 ErrSize:= 0;
 ErrStr:= nil;
 res:= T2QSendASyncTrans(LPSTR(AnsiString(outStr)), ErrCode, ErrStr, ErrSize);
 if(res <> TRANS2QUIK_SUCCESS) then
 begin
   FTransID:= 0;
   FTransBusy:= false;
 end else
 begin
   Dt:= now();
   FMemo.Lines.Add(DateToStr(Dt) + ' ' + FormatDateTime('hh:mm:ss.zzz', Now()) +
                   ' --> Ордер ' + ExpData.SpotData.SecCode + ' отправлен.');
 end;
end;

Получение тикета

//--- Transaction callback -----
procedure pfTransReplyCB;
var
 i: integer;
 Child: TMDIChild;
begin
 Mutex.Lock;
 try
   for i:= 0 to MainForm.MDIChildCount - 1 do
   begin
     Child:= TMDIChild(MainForm.MDIChildren[i]);
     if(Child <> nil) then
     begin
       if(dwTransId = Child.Expert.TransID) then
       begin
         if(nTransactionResult = TRANS2QUIK_SUCCESS) then
           Child.Expert.FOrder:= nOrderNum else                //Get order done
             Child.Expert.FTransBusy:= false;                  //Get order fail
         break;
       end;
     end;
   end;
 finally
   Mutex.UnLock;
 end;
end;

Смотрим, что произошло с ордером

//--- Order status callback -----
procedure pfOrderStatusCB;
var
 i: integer;
 Child: TMDIChild;
 StartQty: Quantity;
// s: string;
begin
 if((nMode = 0) and (dwTransID > 0)) then
 begin
   Mutex.Lock;
   try
     for i := 0 to MainForm.MDIChildCount - 1 do
     begin
       Child:= TMDIChild(MainForm.MDIChildren[i]);
       if(Child <> nil) then
       begin
         if(Child.Expert.TransID = dwTransID) then
         begin
           if(dNumber = Child.Expert.Order) then
           begin
             StartQty:= T2QOrderQty(ordDescr);             //Order start volume
             if(string(SecCode) = Child.Expert.ExpData.FutData.SecCode) then //future
             begin
               case nStatus of
                 1: {active};
                 2: begin
                      if(StartQty = nBalance) then                   //Canceled
                      begin
                        Child.Expert.FOrder:= 0;
                        Child.Expert.FTransID:= 0;
                        Child.Expert.FTransBusy:= false;
                      end else
                      begin                                      //Partial done
                        case nIsSell of
                          0: Child.Expert.FFutVol:= Child.Expert.FFutVol + (StartQty - nBalance);
                          else Child.Expert.FFutVol:= Child.Expert.FFutVol - (StartQty - nBalance);
                        end;
                          Child.Expert.FVolume:= StartQty - nBalance;
                          Child.Expert.FaSell:= nIsSell;
                          Child.Expert.FOrder:= 0;
                          PostMessage(Child.Expert.Handle, WM_ON_TRADE,
                                           NativeUint(Child.Expert.Handle), 0);
                      end;
                    end;
                 else begin                                 //Future order Done
                   case nIsSell of
                     0: Child.Expert.FFutVol:= Child.Expert.FFutVol + (StartQty - nBalance);
                     else Child.Expert.FFutVol:= Child.Expert.FFutVol - (StartQty - nBalance);
                   end;
                     Child.Expert.FVolume:= StartQty - nBalance;
                     Child.Expert.FaSell:= nIsSell;
                     Child.Expert.FOrder:= 0;
                     PostMessage(Child.Expert.Handle, WM_ON_TRADE,
                                           NativeUint(Child.Expert.Handle), 0);
                 end;
               end;
               break;
             end else
             if(string(SecCode) = Child.Expert.ExpData.SpotData.SecCode) then  //spot
             begin
               case nStatus of
                 1:{active};
                 2: begin                                            //Canceled
                      Child.Expert.FOrder:= 0;
                      Child.Expert.FTransID:= 0;
                      Child.Expert.FOrder:= 0;
                      Child.Expert.FTransBusy:= false;
                    end;
                 else begin                                   //Spot order Done
                   Child.Expert.FOrder:= 0;
                   Child.Expert.FTransID:= 0;
                   case nIsSell of
                     0: Child.Expert.FSpotVol:= Child.Expert.FSpotVol + (StartQty - nBalance);
                     else Child.Expert.FSpotVol:= Child.Expert.FSpotVol - (StartQty - nBalance);
                   end;
                   Child.Expert.FOrder:= 0;
                   Child.Expert.FTransBusy:= false;
                 end;
               end;
               break;
             end;
           end;
         end;
       end;
     end;
   finally
     Mutex.Unlock;
   end;
 end;
end;

Ничего они делать не будут!
Если бы хотели, то давно бы сделали.
Хотя бы трансляцию маркет дата вместо DDE.

Разрядность переменной для хранения тикета ордера в TRANS2QUIK_API
определена как
typedef unsigned __int64 EntityNumber;

Следовательно переменой EntityNumber хватит для хранения тикетов ордеров.  

Уважаемые разработчики!
Был задан серьезный вопрос.
Почему не отвечаете?

Спасибо!
А что скажут разработчики?

Четыре года минуло....

Собственно вопрос

Ссылки не открываются

1. думается, что выйгрыша в скорости не будет
2. Не знаю
3. Используйте ассинхронную отправку ордеров (в одной строке не получится отправить 2 ордера)

Ну, что и требовалось доказать
Вы ктверждали, что OnTrade быстрее OnOrder , я говорил, что почти одинаково
У Вас в таблицах время OnOr der = OnTrade
На этом можно закончить!

Зачем так "распинаться"?
Ваши умозаключения - просто набор фраз, я пробовал на реале - практически нет разницы onOrder и onTrade.
Я предоставил свои данные, что бы что-то доказать, покажите Ваши.

Больше делать нечего, как цепляться к словам?
Не имеет значения (onOrder и onTrade) пробовал так и так - разницы почти нет,
но использую OnOrder.  

Я не сохранил скрины полностью таблиц.
Фьючерс выставлялся лимитником (т.е цена не могла изменится).
outStr:= 'ACCOUNT=' + ExpData.FutAccaunt + '; TYPE=L; TRANS_ID=' + id +
          '; CLASSCODE=' + ExpData.FutData.ClassCode + '; SECCODE=' +
          ExpData.FutData.SecCode + '; ACTION=NEW_ORDER; OPERATION=' + s +
          '; EXECUTION_CONDITION=KILL_BALANCE' + '; PRICE=' + FloatToStr(price) +
          '; QUANTITY=' + FloatToStr(Qnty) + ';';

Добрый день!
На фондовой секции (у моего брокера Открытие) нет рыночных ордеров.
Поэтому я отсылаю лимитный ордер, цена которого формируется так:
Если покутка, то SellPrice(из стакана минимальная) + 10 * шаг цены, и для продажи
BuyPrice(из стакана максимальная) - 10 * шаг цены.
Т.е ордер должен исполнится мгновенно

Добрый день, Егор!
Если бы вопрос стоял о выставлении ордера, то я бы написал "время исполнения"
Конечно речь идет о сделках.
Ликвидность фондового рынка в разы выше срочного....

Да и вообще, через месяц ГОД будет с последнего изменения вообще во всем разделе
"Утилиты и документация"

Вы хоть когда-нибудь торговали?
Что значит мгновенно? Так вообще не бывает да же на FIX, Plaza II и пр.
Не фантазируйте, пожалуйста!

Добрый день!

Скажите, уважаемые разработчики, почему время исполнения ордеров на ФОРТС в разы меньше, чем на Фондовой секции?
Ордер SRH9 отправлен: 15.02.19 20:30:12
Ордер SRH9 исполнился: 15.02.19 20:30:12 (62 мс)
Ордер SBER отправлен: 15.02.19 20:30:12
Ордер SBER исполнился: 15.02.19 20:30:13 (562 мс)

Ордер SRH9 отправлен: 15.02.19 20:30:13
Ордер SRH9 исполнился: 15.02.19 20:30:13 (250 мс)
Ордер SBER отправлен: 15.02.19 20:30:13
Ордер SBER исполнился: 15.02.19 20:30:14 (561 мс)

Ордер SRH9 отправлен: 15.02.19 20:30:14
Ордер SRH9 исполнился: 15.02.19 20:30:14 (125 мс)
Ордер SBER отправлен: 15.02.19 20:30:14
Ордер SBER исполнился: 15.02.19 20:30:15 (749 мс)

Ордер SRH9 отправлен: 15.02.19 20:30:16
Ордер SRH9 исполнился: 15.02.19 20:30:16 (124 мс)
Ордер SBER отправлен: 15.02.19 20:30:16
Ордер SBER исполнился: 15.02.19 20:30:17 (999 мс)

Ордер SRH9 отправлен: 15.02.19 20:31:23
Ордер SRH9 исполнился: 15.02.19 20:31:23 (125 мс)
Ордер SBER отправлен: 15.02.19 20:31:23
Ордер SBER исполнился: 15.02.19 20:31:24 (1560 мс)

Ордер SRH9 отправлен: 15.02.19 20:31:27
Ордер SRH9 исполнился: 15.02.19 20:31:27 (109 мс)
Ордер SBER отправлен: 15.02.19 20:31:27
Ордер SBER исполнился: 15.02.19 20:31:28 (1014 мс)

Ордер SRH9 отправлен: 15.02.19 20:31:29
Ордер SRH9 исполнился: 15.02.19 20:31:29 (187 мс)
Ордер SBER отправлен: 15.02.19 20:31:29
Ордер SBER исполнился: 15.02.19 20:31:30 (1202 мс)

Ордер SRH9 отправлен: 15.02.19 20:31:31
Ордер SRH9 исполнился: 15.02.19 20:31:31 (202 мс)
Ордер SBER отправлен: 15.02.19 20:31:31
Ордер SBER исполнился: 15.02.19 20:31:32 (796 мс)

Ордер SRH9 отправлен: 15.02.19 20:31:32
Ордер SRH9 исполнился: 15.02.19 20:31:33 (109 мс)
Ордер SBER отправлен: 15.02.19 20:31:33
Ордер SBER исполнился: 15.02.19 20:31:34 (1435 мс)

Ордер SRH9 отправлен: 15.02.19 20:31:36
Ордер SRH9 исполнился: 15.02.19 20:31:36 (203 мс)
Ордер SBER отправлен: 15.02.19 20:31:36
Ордер SBER исполнился: 15.02.19 20:31:37 (437 мс)

Ордер SRH9 отправлен: 15.02.19 20:31:41
Ордер SRH9 исполнился: 15.02.19 20:31:41 (125 мс)
Ордер SBER отправлен: 15.02.19 20:31:41
Ордер SBER исполнился: 15.02.19 20:31:42 (873 мс)

Ордер SRH9 отправлен: 15.02.19 20:31:42
Ордер SRH9 исполнился: 15.02.19 20:31:42 (109 мс)
Ордер SBER отправлен: 15.02.19 20:31:42
Ордер SBER исполнился: 15.02.19 20:31:43 (687 мс)

Ордер SRH9 отправлен: 15.02.19 20:31:51
Ордер SRH9 исполнился: 15.02.19 20:31:51 (140 мс)
Ордер SBER отправлен: 15.02.19 20:31:51
Ордер SBER исполнился: 15.02.19 20:31:51 (312 мс)

Ордер SRH9 отправлен: 15.02.19 20:31:56
Ордер SRH9 исполнился: 15.02.19 20:31:56 (109 мс)
Ордер SBER отправлен: 15.02.19 20:31:56
Ордер SBER исполнился: 15.02.19 20:31:57 (1186 мс)

Сегодня попробовал сделать то же самое в КВИКе
Вот что получилось

Правда, конец измерения приходится не на колбэк TRANS2QUIK_TRADE_STATUS_CALLBACK
а на TRANS2QUIK_ORDER_STATUS_CALLBACK, т.к в первом случае мы получаем несколько сообщений,
а во втором просто проверяем nStatus

Но самое интересное не в этом. У меня в Открывашке на реале стоит квик 7.19.0.51
Если посмотреть время выставления ордеров (ассинхронные ордера) и время их исполнения, то из этих данных
вообще ничго понять не возможно (время одинаковое)

Уже 5 месяцев прошло...

Спасибо, разобрался.

Добрый!
Спасибо, понятно.

Я, тебе хам, не Мишаня!
Поучи свою жену ЩИ варить, а я уж как-нибудь сам разбурусь куда мне
смотреть и что делать!

Модераторы!
Немного странно, что Вы становитесь на сторону откровенного хама, удаляя сообщение одной из сторон.
Может быть Вам не нравятся не лестные отзывы о Вашем "детище"?

Вот, например, ответ Егора Зайцева, на найденую мной ошибку
"Добрый день,
     
     Действительно, в настоящее время терминал при получении подписки       от Trans2QUIK на получение заявок и сделок не проверяет валидность       указанных в подписке кодов классов и инструментов.
     Данная ошибка не может привести ни к каким серьёзным последствиям       и  будет исправлена в одной из очередных версий ПО.
     
     Приносим извинения за причиненные неудобства."

Добрый!
О тех ошибках, которые описаны, здесь, на форуме, которые Вы сами признали
и обещали испраить в ближайшем билде (обновлении).

*)*)
MT5
2019.02.07 12:12:59.299 Trades 'ххххх': buy limit 2.00 LKOH-9.19 at 54273
2019.02.07 12:12:59.308 Trades 'ххххх': accepted buy limit 2.00 LKOH-9.19 at 54273
2019.02.07 12:12:59.309 Trades 'ххххх': buy limit 2.00 LKOH-9.19 at 54273 placed for execution in 10.614 ms

Советник
Print(__FUNCTION__, " Ордер ", trans.order, " размещен за ", DoubleToString(NormalizeDouble(MathAbs((stop_time_test - start_time_test) /1000), 3)));

2019.02.07 12:12:59.316 FCS_Trader (LKOH-6.19,M1) OnTradeTransaction Ордер 99220131 размещен за 17.00000000

в 4 не было OnTradeTransaction() многое изменилось...

Если Вы программировали в МТ5 (тогда будет понятен смысл моих слов), то лично для Вас (из принципа) могу сделать коректный замер.
Т.е сделаю GetMicrosecondCount(); перед отправкой ассинхронного ордера, и GetMicrosecondCount(); когда придет ответ от cервера
в OnTradeTransaction(). Я раньше это делал (у меня получалось 5-9 мс)

Да вообще по-барабану сколько мс 7-15 мс.
Я вообще не собирался что-то доказывать и измерять.
Просто к слову сказал, то что я сам вижу в обоих терминалах.
На мой взляд МТ5 работает гораздо быстрее, но он имеет очень много
"своих" недостатков (н-р только фьючерсы). К слову будет сказано, что лично
у меня больше претензий имеено к МТ5 нежели к квик, но последний (как платформа для роботов) ....

Что Вы хотите сказать (доказать)?
Что одна глюкавка лучше другой?
Мне ничего рассазывать (доказывать) не нужно я и программирую и торгую (на реале) в обоих
терминалах не один год. И как они работаю мне прекрано известно.

И он спрашивал не про МТ5, а про КВИК

Ну, а как пинг до роутера 1 мс?

Тогда вопрос прозвучит так:
А в какой срок собираетесь исправить ошибки?

Спасибо

А что это Вам даст?

//+------------------------------------------------------------------+
//| Place order                                                      |
//+------------------------------------------------------------------+
void COrder::Place(const double price, const double volume, const bool buy_sell)
{
 MqlTradeRequest request = {0};
 MqlTradeResult  result  = {0};
 ticket = 0;
 req_id = 0;
 mem_magic = magic_storage + 1;
 check_count = 0;
 if(magic_storage >= (magic_number + 65530)) mem_magic = magic_number;
//--- Fill structure
 request.action = TRADE_ACTION_PENDING;
 request.magic  = mem_magic;
 request.symbol = a_symbol;
 request.volume = volume;
 request.price  = price;
 if(buy_sell)
 {
   request.type = ORDER_TYPE_BUY_LIMIT;
 }
 else
 {
   request.type = ORDER_TYPE_SELL_LIMIT;
 }
 request.comment = "Отложенный ордер...";      
 request.type_filling = ORDER_FILLING_RETURN;
 request.type_time = ORDER_TIME_DAY;
//--- Send order
 if(OrderSendAsync(request, result) == true)
 {
   if((result.retcode == TRADE_RETCODE_PLACED) || (result.retcode == TRADE_RETCODE_DONE))
   {
     req_id = result.request_id;
     magic_storage = mem_magic;
     state = ORD_DO_SET;
     mem_time = GetMicrosecondCount();
     mem_start_time = TimeCurrent();
     SetTransCount();
   }
   else
   {
     mem_magic = 0;
     mem_time = 0;
     mem_start_time = 0;
     CheckError(result.retcode, "Place: Ордер не установлен! Причина: ", order_status, ticket);
   }
 }
 else
 {
   mem_magic = 0;
   mem_time = 0;
   mem_start_time = 0;
   CheckError(result.retcode, "Place: Ордер не отослан! Причина: ", order_status, ticket);
 }
}

У меня нет нужды сравнивать Квик с МТ5 - вывод очевиден (оба оставляют желать лучшего).
Но с точки зрения создания торговых роботов второй на несколько порядков выше первого, да и скорость
исполнения торговых приказов во втором гораздо выше.
Но ни в первом, ни во втором невозможно КАЧЕСТВЕННО торговать роботами на MOEX
Приходится из г...на шарики катать :)

P.S как на этом сайте вставить изображение?

Михаил.
Как Вы тестируете, то, что написано на LUA?
Если текст срипта составляет 50-100 строк, то это как-то можно "пережить", отправляя сообщения,
а если 8000 строк, , да ещё если на 1 инструмент а 50, то как тестировать будете?

Уважаемые разработчики!

Понятно, что точный срок обновления trans2quik.dll невозможно огласить, но
хотелось бы знать ВАШИ планы по срокам выхода обновления.

Не нужно фантазировать. В МТ5, 8 мс - это с момента время отправки транзакци  + время получения ответа от сервера:

Реал

2019.02.06 18:27:25.902 Trades 'xxxxx': cancel order #99190769 sell limit 1.00 SNGR-6.19 at 28521
2019.02.06 18:27:25.908 Trades 'xxxxx': accepted cancel order #99190769 sell limit 1.00 SNGR-6.19 at 28521
2019.02.06 18:27:25.909 Trades 'xxxxx': cancel order #99190769 sell limit 1.00 SNGR-6.19 at 28521 placed for execution in 7.386 ms

Я звонил в Открывашку по этому вопросу.
Ответ:
"Рыночные заявки по фондовому рынку запрещены во избежании манипуляций на рынке"
:)
Оказывается это мы, маленькие частные инвесторы, двигаем рынок!  

Уважаемые разработчики!

"Почините" котировки в фондовой секции.
Например:
Шаг цены акции Роснефти - 0,05, а у Вас в стакане огромное кол-во котировок
не кратных шагу цены.

У меня ассинронная отправка ордеров через Trans2QuikAPI, посылая первый приказ, ожидается ответ и по приходу ответа
совершается вторая сделка. Интернет 100 Мб. Брокер - Открывашка
Задержка между сделками - 250 - 300 мс (для сравнения , с этого же компьютера, в МТ5 - 7-8 мс)

А что из исходного кода Trans2quik.dll нельзя просто, ПОКА, скопировать существующие ошибки?

Вы, Павел, вероятно не ВСЁ читаете...

Вопрос не в том как коннектится, а что делать, если пришло RANS2QUIK_DLL_DISCONNECTED
Я нашел, пока 2 ошибки
109 - терминал был закрыт
233 - запрещен импорт внешних транзакций

Принудительно закрыл терминал.
В TRANS2QUIK_CONNECTION_STATUS_CALLBACK,
TRANS2QUIK_DLL_DISCONNECTED пришла ошибка 109

Техническая поддержка.
Каие варианты ещё возможны?