示例#1
0
        private void FireBroadcast(object sender, BroadcastEventArgs e)
        {
            ClientAdapterBroadcast broadcast = e.Data;

            if (broadcast.Type == ClientAdapterBroadcast.Types.BroadcastType.DEALING)
            {
                DealingEngineBroadcast dealing_broadcast = broadcast.DealingBroadcast;

                if (dealing_broadcast.Type == DealingEngineBroadcast.Types.BroadcastType.UPDATE_STATUS)
                {
                    foreach (SystemParameterData system_parameter in dealing_broadcast.SystemParameterList)
                    {
                        if ("send_to_fix".Equals(system_parameter.Name))
                        {
                            sendToFix.Checked   = "1".Equals(system_parameter.Value);
                            splitButton.Enabled = sendToFix.Checked;
                            return;
                        }
                    }
                }
            }
        }
示例#2
0
        private void FireBroadcast(object sender, BroadcastEventArgs e)
        {
            ClientAdapterBroadcast broadcast = e.Data;

            if (broadcast.Type == ClientAdapterBroadcast.Types.BroadcastType.DEALING)
            {
                DealingEngineBroadcast dealingBroadcast = broadcast.DealingBroadcast;

                if (dealingBroadcast.Type == DealingEngineBroadcast.Types.BroadcastType.ROLLOVER)
                {
                    orders.Clear();
                    releases.Clear();
                    executions.Clear();

                    dispatcher.RolloverCallback(new DealingEventArgs("ROLLOVER"));
                }

                foreach (OrderMessage order in dealingBroadcast.OrderList)
                {
                    if (order.HasOrderData)
                    {
                        Order o = new Order(order.OrderData);

                        foreach (AllocationData data in order.AllocationDataList)
                        {
                            o.AddAllocation(new Allocation(data));
                        }

                        Update(o);
                    }

                    foreach (ReleaseData data in order.ReleaseDataList)
                    {
                        Update(new Release(data));
                    }

                    foreach (ExecutionData data in order.ExecutionDataList)
                    {
                        Update(new Execution(data));
                    }
                }
            }
            else if (broadcast.Type == ClientAdapterBroadcast.Types.BroadcastType.MARKETDATA)
            {
                MarketDataBroadcast marketDataBroadcast = broadcast.MarketdataBroadcast;

                if (marketDataBroadcast.Type == MarketDataBroadcast.Types.BroadcastType.PRICE)
                {
                    foreach (MarketDataPriceData priceData in marketDataBroadcast.PriceDataList)
                    {
                        if (HasInstrument(priceData.InstrumentId))
                        {
                            Instrument instrument = (Instrument)instruments[priceData.InstrumentId];

                            instrument.SetAttribute(
                                DatabaseObject.LAST_PRC,
                                Convert.ToString(priceData.LastPrc));

                            dispatcher.InstrumentChangedCallback(
                                new MarketDataEventArgs(instrument));
                        }
                    }
                }
            }
        }