/// <summary> /// Handle the Inherits changing. /// </summary> /// <param name="sender">The PaymentScheduleControl that owns the property.</param> /// <param name="eventArgs">The event arguments.</param> private static void OnInheritsChanged(DependencyObject sender, DependencyPropertyChangedEventArgs eventArgs) { PaymentScheduleControl schedule = sender as PaymentScheduleControl; if (schedule.Inherits) { FluidTrade.Core.ThreadPoolHelper.QueueUserWorkItem(delegate(object data) { lock (DataModel.SyncRoot) schedule.Dispatcher.BeginInvoke( new WaitCallback(cs => schedule.SetInheritedSchedule(cs as CommissionSchedule)), DispatcherPriority.Normal, new object[] { Blotter.GetEffectiveCommissionSchedule((Guid)data) }); }, schedule.Entity.EntityId); } else { if (schedule.Entity.CommissionSchedule == null) { schedule.Entity.CommissionSchedule = new CommissionSchedule(); } schedule.content.DataContext = schedule.Entity.CommissionSchedule; } }
private void RuntimeConnected() { var topBarAppOptions = new Fin.ApplicationOptions("topBarApp", "topBarApp", UrlRoot + "color.html"); TopBar.Initialize(Runtime.Options, topBarAppOptions); var sideBarAppOptions = new Fin.ApplicationOptions("sideBarApp", "sideBarApp", UrlRoot + "color.html"); SideBar.Initialize(Runtime.Options, sideBarAppOptions); var blotterAppOptions = new Fin.ApplicationOptions("blotterApp", "blotterApp", BlotterUrlRoot); Blotter.Initialize(Runtime.Options, blotterAppOptions); var topChartAppOptions = new Fin.ApplicationOptions("topChartApp", "topChartApp", UrlRoot); TopChart.Initialize(Runtime.Options, topChartAppOptions); var bottomChartAppOptions = new Fin.ApplicationOptions("bottomChartApp", "bottomChartApp", UrlRoot); BottomChart.Initialize(Runtime.Options, bottomChartAppOptions); Fin.InterApplicationBus.Subscription <string>(Runtime, "window-manager/popout").MessageReceived += MainWindow_PopoutMessageReceived; Fin.InterApplicationBus.Subscription <string>(Runtime, "window-manager/popin").MessageReceived += MainWindow_PopinMessageReceived; //WindowManagerChannel = Runtime.InterApplicationBus.Channel.CreateProvider("window-manager"); //WindowManagerChannel.RegisterTopic("popout", new Func<string,object>(OnPopout)); //WindowManagerChannel.RegisterTopic("popin", new Func<string,object>(OnPopin)); //WindowManagerChannel.OpenAsync(); }
public void Dispose() { Reference.Dispose(); Blotter.Dispose(); Execution.Dispose(); Pricing.Dispose(); }
public FormOrder(Blotter blotter) { // This will initialize the IDE maintained components. InitializeComponent(); this.blotter = blotter; // This event is used to hold up the background initialization of the form until a window handle has been created. If // the background thread doesn't wait for this signal, it can cause an exception when trying to pass information to the // foreground using the 'Invoke' commands. this.handleCreatedEvent = new ManualResetEvent(false); // Delegates for handling Windows thread actions from the background. this.initializeDelegate = new InitializeDelegate(InitializeDialog); this.postEndDelegate = new PostEndDelegate(PostEnd); #if DEBUG // This will prevent the background initialization thread from running in the designer (background threads kill the designer. if (LicenseManager.UsageMode != LicenseUsageMode.Designtime) { #endif // The remaining part of the initialization must be done from a background thread. ThreadPool.QueueUserWorkItem(new WaitCallback(InitializationThread)); #if DEBUG } #endif }
public override void Open(object tag) { if (!(tag is Blotter || tag is BlotterWorkingOrderDetail || tag is BlotterMatchDetail)) { throw new Exception(string.Format("Can't display an object of type {0} in this viewer", tag.GetType())); } // Extract the document identity from the Blotter tag. if (tag is Blotter) { this.blotter = (Blotter)tag; this.workingOrders = null; } // Extract the document identity from the BlotterWorkingOrderDetail tag. if (tag is BlotterWorkingOrderDetail) { this.blotter = ((BlotterWorkingOrderDetail)tag).Blotter; this.workingOrders = ((BlotterWorkingOrderDetail)tag).WorkingOrders; } // Extract the document identity from the BlotterMatchDetail tag. if (tag is BlotterMatchDetail) { this.blotter = ((BlotterMatchDetail)tag).Blotter; this.workingOrders = null; } base.Open(tag); }
private static void LoadBlotter(GameObject LoadedObject, SavedObject save) { object[] data = save.CustomDataArray; Blotter blotter = LoadedObject.GetComponent <Blotter>(); blotter.Input.On = (bool)data[0]; blotter.Output.On = (bool)data[1]; }
/// <summary> /// Marshals the data needed to navigate the client application to the accepted item in the Match blotter. /// </summary> /// <param name="parameter">The thread initialization data.</param> private void AcceptNegotiationThread(object parameter) { // Extract the parameters. int matchId = (int)parameter; // The main goal of this section of code is to construct an object that can be used to navigate the // client container to the selected item in the blotter. BlotterMatchDetail blotterMatchDetail = new BlotterMatchDetail(); try { // Lock the tables. System.Diagnostics.Debug.Assert(!ClientMarketData.IsLocked); ClientMarketData.BlotterLock.AcquireReaderLock(ClientTimeout.LockWait); ClientMarketData.MatchLock.AcquireReaderLock(ClientTimeout.LockWait); ClientMarketData.ObjectLock.AcquireReaderLock(ClientTimeout.LockWait); ClientMarketData.WorkingOrderLock.AcquireReaderLock(ClientTimeout.LockWait); // The 'BlotterMatchDetail' can be used to open up a Blotter in a viewer and select the Match. ClientMarketData.MatchRow matchRow = ClientMarketData.Match.FindByMatchId(matchId); if (matchRow != null) { Blotter blotter = new Blotter(matchRow.WorkingOrderRow.BlotterRow.BlotterId); Match match = new Match(matchRow.MatchId); blotterMatchDetail = new BlotterMatchDetail(blotter, new Match[] { match }); } } finally { // Release the locks. if (ClientMarketData.BlotterLock.IsReaderLockHeld) { ClientMarketData.BlotterLock.ReleaseReaderLock(); } if (ClientMarketData.MatchLock.IsReaderLockHeld) { ClientMarketData.MatchLock.ReleaseReaderLock(); } if (ClientMarketData.ObjectLock.IsReaderLockHeld) { ClientMarketData.ObjectLock.ReleaseReaderLock(); } if (ClientMarketData.WorkingOrderLock.IsReaderLockHeld) { ClientMarketData.WorkingOrderLock.ReleaseReaderLock(); } System.Diagnostics.Debug.Assert(!ClientMarketData.IsLocked); } // Notify the owner of this service that it should navigate to the item in the matching blotter that was selected by // the user. if (this.OpenObject != null) { this.OpenObject(this, blotterMatchDetail); } }
public void Add(BlotterDTO dto) { using (var uow = new UnitOfWork(new DataContext())) { var obj = new Blotter(); obj.PersonalInfoID = dto.PersonalInfoID; obj.CreateTimeStamp = DateTime.Now; obj.What = dto.What; obj.Where = dto.Where; obj.When = dto.When; uow.Blotters.Add(obj); uow.Complete(); dto.ID = obj.BlotterID; } }
/// <summary> /// Sets the filter used to select the rows that appear in this viewer. /// </summary> protected void SetFilter() { // This sets the filter when the viewer shows all working orders in a blotter. if (this.content is Blotter) { // This helps to examine the values used to open this document. Blotter blotter = this.content as Blotter; // The root object row is used to find all the descendants to this blotter in the tree structure of objects. When // all the descendants have been found, a string is constructed that will be compiled into the view to select the // rows at the top level of the document. EntityRow entityRow = DataModel.Entity.EntityKey.Find(blotter.BlotterId); if (entityRow != null) { List <Guid> descendants = Hierarchy.GetDescendants(entityRow); string filterSnippet = string.Empty; foreach (Guid objectId in descendants) { filterSnippet += string.Format(filterSnippet == string.Empty ? "sourceOrderRow.WorkingOrderRow.BlotterId=={0}" : "||sourceOrderRow.WorkingOrderRow.BlotterId=={0}", objectId); } } } // This sets the filter when the viewer shows only the selected working orders in a blotter. if (this.content is BlotterWorkingOrderDetail) { // This helps to examine the values used to open this document. BlotterWorkingOrderDetail blotterWorkingOrderDetail = this.content as BlotterWorkingOrderDetail; // This constructs a filter that will show only the selected working orders. If no Working Orders are selected, // then a primitive 'false' is used to satisfy the conditions of the search. string filterSnippet = string.Empty; foreach (WorkingOrder workingOrder in blotterWorkingOrderDetail.WorkingOrders) { filterSnippet += string.Format(filterSnippet == string.Empty ? "sourceOrderRow.WorkingOrderId=={0}" : "||sourceOrderRow.WorkingOrderId=={0}", workingOrder.WorkingOrderId); } } }
/// <summary> /// Creates the DOM and Refreshes the spreadsheet control in the background. /// </summary> /// <remarks> /// This thread is responsible for recreating the Document Object Model for the blotter and translating /// that DOM into a format compatible with the spreadsheet viewer. It will call the foreground when the /// DOM is complete to either update the entire document, if the structure has changed, or only update /// the changed cells, when only the data has changed. /// </remarks> protected override void DrawDocumentCommand(object parameter) { // Extract the document from the thread parameters. Blotter blotter = null; if (parameter is Blotter) { blotter = (Blotter)parameter; } if (parameter is BlotterMatchDetail) { blotter = ((BlotterMatchDetail)parameter).Blotter; } #if DEBUGXML // Create the blotter document. MatchHistoryDocument matchDocument = new MatchHistoryDocument(blotter.BlotterId); // Make sure that writing the debug file doesn't interrupt the session. try { // During debugging, it's very useful to have a copy of the DOM on the disk. matchDocument.Save("matchHistoryDOM.xml"); } catch (Exception exception) { // Write the error and stack trace out to the debug listener EventLog.Error("{0}, {1}", exception.Message, exception.StackTrace); } // This will display the this.XmlDocument = matchDocument; #else // This will display the quote viewer this.XmlDocument = new QuoteDocument(Convert.ToInt32(this.Tag)); #endif }
/// <summary> /// Creates an object that wraps a Markthree.Controls.Report in a Page. /// </summary> public ViewerDebtBlotter(params Object[] arguments) { // This will display the given object in the viewer. this.Content = arguments[0]; this.arguments = new Object[arguments.Length - 1]; Array.Copy(arguments, 1, this.arguments, 0, this.arguments.Length); // This describes the content of the report. if (this.Content is Blotter) { this.blotter = this.Content as Blotter; } // The IDE managed components are initialized here. InitializeComponent(); // Register for these events (do not forget to unregister them later). ViewerDebtBlotter.reportMatch.SelectionChanged += new EventHandler(reportMatch_SelectionChanged); // The delegates will handle the loading and unloading of the viewer into the visual tree. this.Loaded += new RoutedEventHandler(OnLoaded); this.Unloaded += new RoutedEventHandler(OnUnloaded); }
private static void LoadBlotter(GameObject LoadedObject, SavedBlotter save) { Blotter blotter = LoadedObject.GetComponent <Blotter>(); blotter.Output.On = save.OutputOn; }
/// <summary> /// Converts SaveThisObject into serializable data structures /// </summary> /// <param name="obj">The SaveThisObject to convert</param> /// <returns>A serializable Datum containing the data in the SaveThisObject</returns> public static Datum Convert(SaveThisObject obj) { bool panel = obj.ObjectType.StartsWith("Panel") || obj.ObjectType == "Through Blotter"; Datum result = null; switch (obj.ObjectType) { case "CircuitBoard": List <Datum> children = new List <Datum>(obj.transform.childCount); CircuitBoard comp = obj.GetComponent <CircuitBoard>(); foreach (Transform child in obj.transform) { SaveThisObject save = child.GetComponent <SaveThisObject>(); if (save != null) { children.Add(Convert(save)); } } Renderer renderer = obj.GetComponent <Renderer>(); result = new BoardDatum { width = comp.x, height = comp.z, children = children.ToArray(), color = renderer.material.color }; break; case "Wire": result = new WireDatum { isInputInput = obj.GetComponent <InputInputConnection>() != null, localScale = obj.transform.localScale }; break; case "Inverter": NotGate gate = obj.GetComponent <NotGate>(); result = new InverterDatum { inputOn = gate.Input.On, outputOn = gate.Output.On }; break; case "Peg": result = new PegDatum { isOn = obj.GetComponent <CircuitInput>().On }; break; case "Delayer": Delayer delayer = obj.GetComponent <Delayer>(); result = new DelayerDatum { inputOn = delayer.Input.On, outputOn = delayer.Output.On, delayCount = delayer.DelayCount }; break; case "Through Peg": CircuitInput[] inputs = obj.GetComponentsInChildren <CircuitInput>(); result = new ThroughPegDatum { isOn = inputs[0].On }; break; case "Switch": case "Panel Switch": result = new SwitchDatum { panel = panel, isOn = obj.GetComponent <Switch>().On }; break; case "Button": case "Panel Button": Button button = obj.GetComponent <Button>(); result = new ButtonDatum { panel = panel, isOn = button.output.On, downTime = button.ButtonDownTime }; break; case "Display": case "Panel Display": result = new DisplayDatum { panel = panel, isOn = obj.GetComponent <global::Display>().Input.On }; break; case "Label": case "Panel Label": Label label = obj.GetComponent <Label>(); result = new LabelDatum { panel = panel, text = label.text.text, fontSize = label.text.fontSize }; break; case "Blotter": case "Through Blotter": Blotter blotter = obj.GetComponent <Blotter>(); result = new BlotterDatum { through = panel, inputOn = blotter.Input.On, outputON = blotter.Output.On }; break; } result.localPosition = obj.transform.localPosition; result.localAngles = obj.transform.localEulerAngles; return(result); }
public BlotterWorkingOrderDetail(Blotter blotter, WorkingOrder[] workingOrders) { // Initialize the object this.Blotter = blotter; this.WorkingOrders = workingOrders; }
/// <summary> /// Creates a well formed working order document object model. /// </summary> /// <param name="blotterId">The blotter identifies what blocks are to be included in this document.</param> public SourceOrderDocument(Blotter blotter, WorkingOrder[] workingOrders) { try { // Lock the tables System.Diagnostics.Debug.Assert(!ClientMarketData.IsLocked); ClientMarketData.BlotterLock.AcquireReaderLock(CommonTimeout.LockWait); ClientMarketData.DestinationLock.AcquireReaderLock(CommonTimeout.LockWait); ClientMarketData.ObjectLock.AcquireReaderLock(CommonTimeout.LockWait); ClientMarketData.ObjectTreeLock.AcquireReaderLock(CommonTimeout.LockWait); ClientMarketData.OrderTypeLock.AcquireReaderLock(CommonTimeout.LockWait); ClientMarketData.PriceTypeLock.AcquireReaderLock(CommonTimeout.LockWait); ClientMarketData.SecurityLock.AcquireReaderLock(CommonTimeout.LockWait); ClientMarketData.SourceOrderLock.AcquireReaderLock(CommonTimeout.LockWait); ClientMarketData.StatusLock.AcquireReaderLock(CommonTimeout.LockWait); ClientMarketData.StylesheetLock.AcquireReaderLock(CommonTimeout.LockWait); ClientMarketData.TimeInForceLock.AcquireReaderLock(CommonTimeout.LockWait); ClientMarketData.UserLock.AcquireReaderLock(CommonTimeout.LockWait); ClientMarketData.WorkingOrderLock.AcquireReaderLock(CommonTimeout.LockWait); // Create the root element for the document. XmlNode documentNode = this.AppendChild(this.CreateElement("Document")); if (workingOrders == null) { // Find the top level blotter record and recursively construct the report by merging all the children. ClientMarketData.ObjectRow objectRow = ClientMarketData.Object.FindByObjectId(blotter.BlotterId); if (objectRow != null) { RecurseBlotter(documentNode, objectRow); } } else { foreach (WorkingOrder workingOrder in workingOrders) { ClientMarketData.WorkingOrderRow workingOrderRow = ClientMarketData.WorkingOrder.FindByWorkingOrderId(workingOrder.WorkingOrderId); if (workingOrderRow != null) { foreach (ClientMarketData.SourceOrderRow sourceOrderRow in workingOrderRow.GetSourceOrderRows()) { documentNode.AppendChild(new SourceOrderElement(this, sourceOrderRow, FieldArray.Set)); } } } } } catch (Exception exception) { // Write the error and stack trace out to the debug listener EventLog.Error("{0}, {1}", exception.Message, exception.StackTrace); } finally { // Release the table locks. if (ClientMarketData.BlotterLock.IsReaderLockHeld) { ClientMarketData.BlotterLock.ReleaseReaderLock(); } if (ClientMarketData.DestinationLock.IsReaderLockHeld) { ClientMarketData.DestinationLock.ReleaseReaderLock(); } if (ClientMarketData.ObjectLock.IsReaderLockHeld) { ClientMarketData.ObjectLock.ReleaseReaderLock(); } if (ClientMarketData.ObjectTreeLock.IsReaderLockHeld) { ClientMarketData.ObjectTreeLock.ReleaseReaderLock(); } if (ClientMarketData.OrderTypeLock.IsReaderLockHeld) { ClientMarketData.OrderTypeLock.ReleaseReaderLock(); } if (ClientMarketData.PriceTypeLock.IsReaderLockHeld) { ClientMarketData.PriceTypeLock.ReleaseReaderLock(); } if (ClientMarketData.SecurityLock.IsReaderLockHeld) { ClientMarketData.SecurityLock.ReleaseReaderLock(); } if (ClientMarketData.SourceOrderLock.IsReaderLockHeld) { ClientMarketData.SourceOrderLock.ReleaseReaderLock(); } if (ClientMarketData.StatusLock.IsReaderLockHeld) { ClientMarketData.StatusLock.ReleaseReaderLock(); } if (ClientMarketData.StylesheetLock.IsReaderLockHeld) { ClientMarketData.StylesheetLock.ReleaseReaderLock(); } if (ClientMarketData.TimeInForceLock.IsReaderLockHeld) { ClientMarketData.TimeInForceLock.ReleaseReaderLock(); } if (ClientMarketData.UserLock.IsReaderLockHeld) { ClientMarketData.UserLock.ReleaseReaderLock(); } if (ClientMarketData.WorkingOrderLock.IsReaderLockHeld) { ClientMarketData.WorkingOrderLock.ReleaseReaderLock(); } System.Diagnostics.Debug.Assert(!ClientMarketData.IsLocked); } }
/// <summary> /// Handles a change to the blotter property. /// </summary> /// <param name="eventArgs">The unused routed event arguments.</param> protected override void OnEntityChanged(DependencyPropertyChangedEventArgs eventArgs) { Blotter blotter = eventArgs.NewValue as Blotter; FluidTrade.Core.ThreadPoolHelper.QueueUserWorkItem(this.SetBlotter, blotter.EntityId); }
public static SavedObjectV2 CreateSavedObjectFrom(ObjectInfo worldsave) { //SavedObjectV2 newsavedobject = SaveManager.ObjectTypeToSavedObjectType(save.ObjectType); SavedObjectV2 newsavedobject = null; switch (worldsave.ComponentType) { case ComponentType.CustomObject: newsavedobject = new SavedCustomObject(); CreateCustomSavedObject((SavedCustomObject)newsavedobject, worldsave); break; case ComponentType.CircuitBoard: CircuitBoard board = worldsave.GetComponent <CircuitBoard>(); newsavedobject = new SavedCircuitBoard { x = board.x, z = board.z, color = board.GetBoardColor }; break; case ComponentType.Wire: InputInputConnection IIConnection = worldsave.GetComponent <InputInputConnection>(); newsavedobject = new SavedWire { InputInput = IIConnection, length = worldsave.transform.localScale.z }; break; case ComponentType.Button: newsavedobject = new SavedButton(); break; case ComponentType.PanelButton: newsavedobject = new SavedPanelButton(); break; case ComponentType.Delayer: Delayer delayer = worldsave.GetComponent <Delayer>(); newsavedobject = new SavedDelayer { OutputOn = delayer.Output.On, DelayCount = delayer.DelayCount }; break; case ComponentType.Display: Display display = worldsave.GetComponentInChildren <Display>(); newsavedobject = new SavedDisplay { Color = display.DisplayColor }; break; case ComponentType.PanelDisplay: Display paneldisplay = worldsave.GetComponentInChildren <Display>(); newsavedobject = new SavedPanelDisplay { Color = paneldisplay.DisplayColor }; break; case ComponentType.Inverter: Inverter notgate = worldsave.GetComponent <Inverter>(); newsavedobject = new SavedInverter { OutputOn = notgate.Output.On }; break; case ComponentType.Label: Label label = worldsave.GetComponent <Label>(); newsavedobject = new SavedLabel { text = label.text.text, FontSize = label.text.fontSize }; break; case ComponentType.PanelLabel: Label panellabel = worldsave.GetComponent <Label>(); newsavedobject = new SavedPanelLabel { text = panellabel.text.text, FontSize = panellabel.text.fontSize }; break; case ComponentType.Switch: // SWITCH-F*****G-CEPTION Switch circuitswitch = worldsave.GetComponentInChildren <Switch>(); newsavedobject = new SavedSwitch { on = circuitswitch.On }; break; case ComponentType.PanelSwitch: Switch panelswitch = worldsave.GetComponentInChildren <Switch>(); newsavedobject = new SavedPanelSwitch { on = panelswitch.On }; break; case ComponentType.Peg: newsavedobject = new SavedPeg(); break; case ComponentType.ThroughPeg: newsavedobject = new SavedThroughPeg(); break; case ComponentType.Blotter: Blotter blotter = worldsave.GetComponent <Blotter>(); newsavedobject = new SavedBlotter { OutputOn = blotter.Output.On }; break; case ComponentType.ThroughBlotter: Blotter throughblotter = worldsave.GetComponent <Blotter>(); newsavedobject = new SavedThroughBlotter { OutputOn = throughblotter.Output.On }; break; case ComponentType.ColorDisplay: newsavedobject = new SavedColorDisplay(); break; case ComponentType.PanelColorDisplay: newsavedobject = new SavedPanelColorDisplay(); break; case ComponentType.Noisemaker: Noisemaker noisemaker = worldsave.GetComponentInChildren <Noisemaker>(); newsavedobject = new SavedNoisemaker { ToneFrequency = noisemaker.ToneFrequency }; break; case ComponentType.SnappingPeg: newsavedobject = new SavedSnappingPeg(); break; case ComponentType.Mount: newsavedobject = new SavedMount(); break; case ComponentType.VerticalSnappingPeg: newsavedobject = new SavedVerticalSnappingPeg(); break; case ComponentType.none: Debug.LogError("BIG ERROR tried to save a component with no type!"); break; } newsavedobject.LocalPosition = worldsave.transform.localPosition; newsavedobject.LocalEulerAngles = worldsave.transform.localEulerAngles; if (newsavedobject.CanHaveChildren) { newsavedobject.Children = FindChildSaves(worldsave); } return(newsavedobject); }
public BlotterMatchDetail(Blotter blotter, Match[] matches) { // Initialize the object this.Blotter = blotter; this.Matches = matches; }