/// <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;
}
