private void sandDockManager1_DockControlAdded(object sender, TD.SandDock.DockControlEventArgs e)
{
AppendLog("DockControl Added: " + e.DockControl.Text);
e.DockControl.AutoHidePopupOpened += new EventHandler(OnDockControlAutoHidePopupOpened);
e.DockControl.AutoHidePopupClosed += new EventHandler(OnDockControlAutoHidePopupClosed);
e.DockControl.Closed += new EventHandler(OnDockControlClosed);
e.DockControl.Load += new EventHandler(OnDockControlLoad);
e.DockControl.DockSituationChanged += new EventHandler(OnDockControlDockSituationChanged);
}
private void MenuItem_BeforePopup(object sender, TD.SandBar.MenuPopupEventArgs e) {
try {
if (sender == this.dropDownMenuItemValidator) {
// Get Validator
this.menuButtonItemPGdb.Checked = (WorkspaceValidator.Default.Validator is PersonalGeodatabaseValidator);
this.menuButtonItemFGdb.Checked = (WorkspaceValidator.Default.Validator is FileGeodatabaseValidator);
// Clear SDE Connection Items
this.menuButtonItemSdeConnection.Items.Clear();
// Find ArcCatalog SDE Connections
string applicationData = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
string esri = System.IO.Path.Combine(applicationData, "ESRI");
string arcCatalog = System.IO.Path.Combine(esri, "ArcCatalog");
if (!Directory.Exists(arcCatalog)) {
MenuButtonItem menuButton = new MenuButtonItem();
menuButton.Enabled = false;
menuButton.Text = Resources.TEXT_NOT_AVAILABLE_BR;
this.menuButtonItemSdeConnection.Items.Add(menuButton);
return;
}
// Get List of SDE Connections
string[] files = Directory.GetFiles(arcCatalog, "*.sde", SearchOption.TopDirectoryOnly);
if (files.Length == 0) {
MenuButtonItem menuButton = new MenuButtonItem();
menuButton.Enabled = false;
menuButton.Text = Resources.TEXT_NONE_BR;
this.menuButtonItemSdeConnection.Items.Add(menuButton);
return;
}
// Add an Item for each SDE Connection
foreach (string file in files) {
string filename = System.IO.Path.GetFileNameWithoutExtension(file);
MenuButtonItem menuButton = new MenuButtonItem();
menuButton.Enabled = true;
menuButton.Text = filename;
menuButton.Tag = file;
menuButton.Activate += new EventHandler(this.MenuItem_Activate);
this.menuButtonItemSdeConnection.Items.Add(menuButton);
}
}
else if (sender == this.menuButtonItemSdeConnection) {
// Get SDE Validator
SdeValidator sdeValidator = WorkspaceValidator.Default.Validator as SdeValidator;
if (sdeValidator == null) { return; }
// Check if SDE Connection File match
foreach (MenuButtonItem item in this.menuButtonItemSdeConnection.Items) {
if (item.Tag == null) { continue; }
string itemTag = item.Tag.ToString();
item.Checked = (itemTag == sdeValidator.SdeFile);
}
}
else if (sender == this.contextMenuBarItemErrorList) {
this.menuButtonItemScroll.Enabled = (this.listViewErrorList.SelectedItems.Count == 1);
this.menuButtonItemSelect.Enabled = (this.listViewErrorList.SelectedItems.Count > 0);
this.menuButtonItemFlashError.Enabled = (this.listViewErrorList.SelectedItems.Count > 0);
this.menuButtonItemClearError.Enabled = (this.listViewErrorList.SelectedItems.Count > 0);
this.menuButtonItemClearAllErrors.Enabled = (this.listViewErrorList.Items.Count > 0);
}
}
catch (Exception ex) {
ExceptionDialog.HandleException(ex);
}
}
/// <summary>
/// Document closing event.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void GettingStarted_Closing(object sender, TD.SandDock.DockControlClosingEventArgs e)
{
this.ApplicationForm.CloseGettingStarted();
}
private void toolBarFormatting_ButtonClick(object sender, TD.SandBar.ToolBarItemEventArgs e)
{
string selectedText = richTextBox1.SelectedText;
if (e.Item == buttonItemBold)
{
richTextBox1.SelectedText = String.Format("{0}{1}{2}", "*", selectedText, "*");
}
else if (e.Item == buttonItemItalic)
{
richTextBox1.SelectedText = String.Format("{0}{1}{2}", "_", selectedText, "_");
}
else if (e.Item == buttonItemUnderline)
{
richTextBox1.SelectedText = String.Format("{0}{1}{2}", "+", selectedText, "+");
}
else if (e.Item == buttonItemOrderedList)
{
richTextBox1.SelectedText = FormatList(selectedText, "1. ");
}
else if (e.Item == buttonItemUnorderedList)
{
richTextBox1.SelectedText = FormatList(selectedText, "* ");
}
else if (e.Item == buttonItemInsertLink)
{
richTextBox1.SelectedText = String.Format("\"{0}\":{1}", selectedText, "<enterUrl>");
}
else if (e.Item == buttonItemInsertHorizonalRule)
{
richTextBox1.SelectedText = String.Format("{0}\n{1}", "----", selectedText);
}
}
private void menuBar1_ButtonClick(object sender, TD.SandBar.ToolBarItemEventArgs e)
{
}
private static void OnScheduledWork(object state)
{
Scheduler thisPtr = (Scheduler)state;
// We snapshot these values here so that we can
// use them after calling OnSchedulerIdle.
bool isTracingEnabled = TD.IsEnd2EndActivityTracingEnabled() && TD.ShouldTraceToTraceSource(EventLevel.Informational);
Guid oldActivityId = Guid.Empty;
Guid workflowInstanceId = Guid.Empty;
if (isTracingEnabled)
{
oldActivityId = TD.CurrentActivityId;
workflowInstanceId = thisPtr._callbacks.WorkflowInstanceId;
TD.TraceTransfer(workflowInstanceId);
if (thisPtr._resumeTraceRequired)
{
if (TD.WorkflowActivityResumeIsEnabled())
{
TD.WorkflowActivityResume(workflowInstanceId);
}
}
}
thisPtr._callbacks.ThreadAcquired();
RequestedAction nextAction = s_continueAction;
bool idleOrPaused = false;
while (object.ReferenceEquals(nextAction, s_continueAction))
{
if (thisPtr.IsIdle || thisPtr._isPausing)
{
idleOrPaused = true;
break;
}
// cycle through (queue->thisPtr.firstWorkItem->currentWorkItem)
WorkItem currentWorkItem = thisPtr._firstWorkItem;
// promote an item out of our work queue if necessary
if (thisPtr._workItemQueue != null && thisPtr._workItemQueue.Count > 0)
{
thisPtr._firstWorkItem = thisPtr._workItemQueue.Dequeue();
}
else
{
thisPtr._firstWorkItem = null;
}
if (TD.ExecuteWorkItemStartIsEnabled())
{
TD.ExecuteWorkItemStart();
}
nextAction = thisPtr._callbacks.ExecuteWorkItem(currentWorkItem);
if (TD.ExecuteWorkItemStopIsEnabled())
{
TD.ExecuteWorkItemStop();
}
}
bool notifiedCompletion = false;
bool isInstanceComplete = false;
if (idleOrPaused || object.ReferenceEquals(nextAction, s_abortAction))
{
thisPtr._isPausing = false;
thisPtr._isRunning = false;
thisPtr.NotifyWorkCompletion();
notifiedCompletion = true;
if (isTracingEnabled)
{
isInstanceComplete = thisPtr._callbacks.IsCompleted;
}
// After calling SchedulerIdle we no longer have the lock. That means
// that any subsequent processing in this method won't have the single
// threaded guarantee.
thisPtr._callbacks.SchedulerIdle();
}
else if (!object.ReferenceEquals(nextAction, s_yieldSilentlyAction))
{
Fx.Assert(nextAction is NotifyUnhandledExceptionAction, "This is the only other option");
NotifyUnhandledExceptionAction notifyAction = (NotifyUnhandledExceptionAction)nextAction;
// We only set isRunning back to false so that the host doesn't
// have to treat this like a pause notification. As an example,
// a host could turn around and call run again in response to
// UnhandledException without having to go through its operation
// dispatch loop first (or request pause again). If we reset
// isPausing here then any outstanding operations wouldn't get
// signaled with that type of host.
thisPtr._isRunning = false;
thisPtr.NotifyWorkCompletion();
notifiedCompletion = true;
if (isTracingEnabled)
{
isInstanceComplete = thisPtr._callbacks.IsCompleted;
}
thisPtr._callbacks.NotifyUnhandledException(notifyAction.Exception, notifyAction.Source);
}
if (isTracingEnabled)
{
if (notifiedCompletion)
{
if (isInstanceComplete)
{
if (TD.WorkflowActivityStopIsEnabled())
{
TD.WorkflowActivityStop(workflowInstanceId);
}
}
else
{
if (TD.WorkflowActivitySuspendIsEnabled())
{
TD.WorkflowActivitySuspend(workflowInstanceId);
}
}
}
TD.CurrentActivityId = oldActivityId;
}
}
public override bool CheckAccess(EndpointIdentity identity, AuthorizationContext authContext)
{
EventTraceActivity eventTraceActivity = null;
if (identity == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("identity");
}
if (authContext == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("authContext");
}
if (FxTrace.Trace.IsEnd2EndActivityTracingEnabled)
{
eventTraceActivity = EventTraceActivityHelper.TryExtractActivity((OperationContext.Current != null) ? OperationContext.Current.IncomingMessage : null);
}
for (int i = 0; i < authContext.ClaimSets.Count; ++i)
{
ClaimSet claimSet = authContext.ClaimSets[i];
if (claimSet.ContainsClaim(identity.IdentityClaim))
{
SecurityTraceRecordHelper.TraceIdentityVerificationSuccess(eventTraceActivity, identity, identity.IdentityClaim, this.GetType());
return(true);
}
// try Claim equivalence
string expectedSpn = null;
if (ClaimTypes.Dns.Equals(identity.IdentityClaim.ClaimType))
{
expectedSpn = string.Format(CultureInfo.InvariantCulture, "host/{0}", (string)identity.IdentityClaim.Resource);
Claim claim = CheckDnsEquivalence(claimSet, expectedSpn);
if (claim != null)
{
SecurityTraceRecordHelper.TraceIdentityVerificationSuccess(eventTraceActivity, identity, claim, this.GetType());
return(true);
}
}
// Allow a Sid claim to support UPN, and SPN identities
SecurityIdentifier identitySid = null;
if (ClaimTypes.Sid.Equals(identity.IdentityClaim.ClaimType))
{
identitySid = GetSecurityIdentifier(identity.IdentityClaim);
}
else if (ClaimTypes.Upn.Equals(identity.IdentityClaim.ClaimType))
{
identitySid = ((UpnEndpointIdentity)identity).GetUpnSid();
}
else if (ClaimTypes.Spn.Equals(identity.IdentityClaim.ClaimType))
{
identitySid = ((SpnEndpointIdentity)identity).GetSpnSid();
}
else if (ClaimTypes.Dns.Equals(identity.IdentityClaim.ClaimType))
{
identitySid = new SpnEndpointIdentity(expectedSpn).GetSpnSid();
}
if (identitySid != null)
{
Claim claim = CheckSidEquivalence(identitySid, claimSet);
if (claim != null)
{
SecurityTraceRecordHelper.TraceIdentityVerificationSuccess(eventTraceActivity, identity, claim, this.GetType());
return(true);
}
}
}
SecurityTraceRecordHelper.TraceIdentityVerificationFailure(identity, authContext, this.GetType());
if (TD.SecurityIdentityVerificationFailureIsEnabled())
{
TD.SecurityIdentityVerificationFailure(eventTraceActivity);
}
return(false);
}
internal BookmarkScope CreateAndRegisterScope(Guid scopeId, BookmarkScopeHandle scopeHandle)
{
if (_bookmarkManagers == null)
{
_bookmarkManagers = new Dictionary <BookmarkScope, BookmarkManager>();
}
BookmarkScope scope = null;
if (scopeId == Guid.Empty)
{
//
// This is the very first activity which started the sub-instance
//
scope = new BookmarkScope(GetNextTemporaryId());
_bookmarkManagers.Add(scope, new BookmarkManager(scope, scopeHandle));
if (TD.CreateBookmarkScopeIsEnabled())
{
TD.CreateBookmarkScope(ActivityUtilities.GetTraceString(scope));
}
if (_uninitializedScopes == null)
{
_uninitializedScopes = new List <BookmarkScope>();
}
_uninitializedScopes.Add(scope);
}
else
{
//
// Try to find one in the existing sub-instances
//
foreach (BookmarkScope eachScope in _bookmarkManagers.Keys)
{
if (eachScope.Id.Equals(scopeId))
{
scope = eachScope;
break;
}
}
//
// We did not find one, e.g. the first receive will get the correlation id from the
// correlation channel
//
if (scope == null)
{
scope = new BookmarkScope(scopeId);
_bookmarkManagers.Add(scope, new BookmarkManager(scope, scopeHandle));
if (TD.CreateBookmarkScopeIsEnabled())
{
TD.CreateBookmarkScope(string.Format(CultureInfo.InvariantCulture, "Id: {0}", ActivityUtilities.GetTraceString(scope)));
}
}
CreateAssociatedKey(scope);
}
return(scope);
}
/*
* Negotiation consists of the following steps (some may be async in the async case):
* 1. Create negotiation state
* 2. Initialize channel factories
* 3. Create an channel
* 4. Open the channel
* 5. Create the next message to send to server
* 6. Send the message and get reply
* 8. Process incoming message and get next outgoing message.
* 9. If no outgoing message, then negotiation is over. Go to step 11.
* 10. Goto step 6
* 11. Close the IRequest channel and complete
*/
protected SecurityToken DoNegotiation(TimeSpan timeout)
{
ThrowIfClosedOrCreated();
SecurityTraceRecordHelper.TraceBeginSecurityNegotiation(this, this.targetAddress);
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
IRequestChannel rstChannel = null;
T negotiationState = null;
TimeSpan timeLeft = timeout;
int legs = 1;
try
{
negotiationState = this.CreateNegotiationState(this.targetAddress, this.via, timeoutHelper.RemainingTime());
InitializeNegotiationState(negotiationState);
this.InitializeChannelFactories(negotiationState.RemoteAddress, timeoutHelper.RemainingTime());
rstChannel = this.CreateClientChannel(negotiationState.RemoteAddress, this.via);
rstChannel.Open(timeoutHelper.RemainingTime());
Message nextOutgoingMessage = null;
Message incomingMessage = null;
SecurityToken serviceToken = null;
for (;;)
{
nextOutgoingMessage = this.GetNextOutgoingMessage(incomingMessage, negotiationState);
if (incomingMessage != null)
{
incomingMessage.Close();
}
if (nextOutgoingMessage != null)
{
using (nextOutgoingMessage)
{
EventTraceActivity eventTraceActivity = null;
if (TD.MessageSentToTransportIsEnabled())
{
eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(nextOutgoingMessage);
}
TraceUtility.ProcessOutgoingMessage(nextOutgoingMessage, eventTraceActivity);
timeLeft = timeoutHelper.RemainingTime();
incomingMessage = rstChannel.Request(nextOutgoingMessage, timeLeft);
if (incomingMessage == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException(SR.GetString(SR.FailToRecieveReplyFromNegotiation)));
}
if (eventTraceActivity == null && TD.MessageReceivedFromTransportIsEnabled())
{
eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(incomingMessage);
}
TraceUtility.ProcessIncomingMessage(incomingMessage, eventTraceActivity);
}
legs += 2;
}
else
{
if (!negotiationState.IsNegotiationCompleted)
{
throw TraceUtility.ThrowHelperError(new SecurityNegotiationException(SR.GetString(SR.NoNegotiationMessageToSend)), incomingMessage);
}
try
{
rstChannel.Close(timeoutHelper.RemainingTime());
}
catch (CommunicationException e)
{
DiagnosticUtility.TraceHandledException(e, TraceEventType.Information);
rstChannel.Abort();
}
catch (TimeoutException e)
{
if (TD.CloseTimeoutIsEnabled())
{
TD.CloseTimeout(e.Message);
}
DiagnosticUtility.TraceHandledException(e, TraceEventType.Information);
rstChannel.Abort();
}
rstChannel = null;
this.ValidateAndCacheServiceToken(negotiationState);
serviceToken = negotiationState.ServiceToken;
SecurityTraceRecordHelper.TraceEndSecurityNegotiation(this, serviceToken, this.targetAddress);
break;
}
}
return(serviceToken);
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
if (e is TimeoutException)
{
e = new TimeoutException(SR.GetString(SR.ClientSecurityNegotiationTimeout, timeout, legs, timeLeft), e);
}
EndpointAddress temp = (negotiationState == null) ? null : negotiationState.RemoteAddress;
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(WrapExceptionIfRequired(e, temp, this.issuerAddress));
}
finally
{
Cleanup(rstChannel, negotiationState);
}
}
private List<PropertyGrid> GetPropertyGrids(TD.SandDock.TabControl tabControl) {
List<PropertyGrid> propertyGrids = new List<PropertyGrid>();
foreach (TD.SandDock.TabPage tabPage in tabControl.TabPages) {
if (tabPage.Controls.Count == 0) { continue; }
if (tabPage.Controls[0] is TD.SandDock.TabControl) {
TD.SandDock.TabControl tabControl2 = (TD.SandDock.TabControl)tabPage.Controls[0];
List<PropertyGrid> propertyGrids2 = this.GetPropertyGrids(tabControl2);
foreach (PropertyGrid propertyGrid2 in propertyGrids2) {
propertyGrids.Add(propertyGrid2);
}
}
else if (tabPage.Controls[0] is PropertyGrid){
propertyGrids.Add((PropertyGrid)tabPage.Controls[0]);
}
}
return propertyGrids;
}
private PropertyGrid SelectedPropertGrid(TD.SandDock.TabControl tabControl){
TD.SandDock.TabPage tabPage = tabControl.SelectedPage;
if (tabPage == null){return null;}
if (tabPage.Controls.Count == 0){return null;}
if (tabPage.Controls[0] is TD.SandDock.TabControl) {
return this.SelectedPropertGrid((TD.SandDock.TabControl)tabPage.Controls[0]);
}
if (tabPage.Controls[0] is PropertyGrid) {
return (PropertyGrid)tabPage.Controls[0];
}
return null;
}
GenericXmlSecurityToken DoOperation(SecuritySessionOperation operation, EndpointAddress target, Uri via, SecurityToken currentToken, TimeSpan timeout)
{
if (target == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("target");
}
if (operation == SecuritySessionOperation.Renew && currentToken == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("currentToken");
}
IRequestChannel channel = null;
try
{
SecurityTraceRecordHelper.TraceBeginSecuritySessionOperation(operation, target, currentToken);
channel = this.CreateChannel(operation, target, via);
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
channel.Open(timeoutHelper.RemainingTime());
object requestState;
GenericXmlSecurityToken issuedToken;
using (Message requestMessage = this.CreateRequest(operation, target, currentToken, out requestState))
{
EventTraceActivity eventTraceActivity = null;
if (TD.MessageReceivedFromTransportIsEnabled())
{
eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(requestMessage);
}
TraceUtility.ProcessOutgoingMessage(requestMessage, eventTraceActivity);
using (Message reply = channel.Request(requestMessage, timeoutHelper.RemainingTime()))
{
if (reply == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException(SR.GetString(SR.FailToRecieveReplyFromNegotiation)));
}
if (eventTraceActivity == null && TD.MessageReceivedFromTransportIsEnabled())
{
eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(reply);
}
TraceUtility.ProcessIncomingMessage(reply, eventTraceActivity);
ThrowIfFault(reply, this.targetAddress);
issuedToken = ProcessReply(reply, operation, requestState);
ValidateKeySize(issuedToken);
}
}
channel.Close(timeoutHelper.RemainingTime());
this.OnOperationSuccess(operation, target, issuedToken, currentToken);
return(issuedToken);
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
if (e is TimeoutException)
{
e = new TimeoutException(SR.GetString(SR.ClientSecuritySessionRequestTimeout, timeout), e);
}
OnOperationFailure(operation, target, currentToken, e, channel);
throw;
}
}
static public void Draw(TC_SelectItemGroup selectItemGroup, float activeMulti, int index, bool nodeFoldout, ref Vector2 pos, Color color)
{
TC_SelectItem selectItem = selectItemGroup.itemList[index];
Undo.RecordObject(selectItem, selectItem.name);
Rect rectPreview;
bool isCulled = false;
if (selectItem.outputId == TC.colorOutput)
{
if (selectItem.texColor != null && selectItem.parentItem.itemList.Count == 1)
{
rectPreview = TD.DrawNode(selectItem, pos, color, Color.white, ref isCulled, activeMulti, nodeFoldout, false, false);
}
else
{
rectPreview = TD.DrawNode(selectItem, pos, color, selectItem.color, ref isCulled, activeMulti, nodeFoldout, false, false);
}
}
else
{
rectPreview = TD.DrawNode(selectItem, pos, color, Color.white, ref isCulled, activeMulti, nodeFoldout, false, !selectItem.splatCustom);
}
if (isCulled || !nodeFoldout)
{
return;
}
if (TC_Settings.instance.hasMasterTerrain)
{
Vector2 sliderPos = TD.GetPositionScaled(new Vector2(pos.x + 10.5f, pos.y + 297.5f));
GUIUtility.ScaleAroundPivot(new Vector2(TD.scale * 2.25f, TD.scale * 2.25f), new Vector2(sliderPos.x, sliderPos.y));
if (selectItem.outputId != TC.objectOutput)
{
if (selectItem.outputId == TC.colorOutput)
{
Color colOld = selectItem.color;
if (Event.current.button != 2)
{
selectItem.color = EditorGUI.ColorField(new Rect(sliderPos.x, sliderPos.y + 4, 93, 10), selectItem.color);
}
else
{
EditorGUI.ColorField(new Rect(sliderPos.x, sliderPos.y + 4, 93, 10), selectItem.color);
}
selectItem.color.a = 1;
if (selectItem.color != colOld)
{
selectItem.Refresh();
}
}
else
{
int selectIndexOld = selectItem.selectIndex;
int total = selectItem.GetItemTotalFromTerrain();
if (total > 1)
{
if (selectItem.outputId == TC.treeOutput)
{
sliderPos.y -= 17;
}
if (Event.current.button != 2)
{
selectItem.selectIndex = (int)GUI.HorizontalSlider(new Rect(sliderPos.x, sliderPos.y, 110, 16), selectItem.selectIndex, 0, total - 1);
}
else
{
GUI.HorizontalSlider(new Rect(sliderPos.x, sliderPos.y, 110, 16), selectItem.selectIndex, 0, total - 1);
}
}
if (selectItem.selectIndex != selectIndexOld)
{
selectItem.Refresh();
}
}
}
if (selectItem.outputId == TC.splatOutput)
{
// if (selectItem.splatCustom) DrawSplatCustomPreview(selectItem, rectPreview);
}
GUI.matrix = Matrix4x4.Scale(new Vector3(1, 1, 1));
TC_NodeGUI.DrawAddItem(rectPreview, pos, selectItem);
TC_NodeGUI.LeftClickMenu(rectPreview, selectItem);
}
if (selectItem.outputId != TC.colorOutput)
{
Rect colorRect = new Rect(rectPreview.x + 0 * TD.scale, rectPreview.y + 0 * TD.scale, 60 * TD.scale, 16f * TD.scale);
GUI.color = new Color(selectItem.color.r, selectItem.color.g, selectItem.color.b, 0.75f);
GUI.DrawTexture(colorRect, Texture2D.whiteTexture);
GUI.color = Color.white;
}
}
bool HandleClientOperationFailure(Exception e)
{
if (TD.RoutingServiceTransmitFailedIsEnabled())
{
TD.RoutingServiceTransmitFailed(null, this.client.Key.ToString(), e);
}
if (!(e is CommunicationException || e is TimeoutException))
{
//We only move to backup for CommunicationExceptions and TimeoutExceptions
return(false);
}
bool canHandle;
MessageRpc messageRpc = this.service.SessionMessages[this.sessionMessageIndex];
SendOperation sendOperation = messageRpc.Operations[this.destinationIndex];
if ((e is CommunicationObjectAbortedException || e is CommunicationObjectFaultedException) &&
!this.channelExtension.HasSession)
{
// Messages on a non sessionful channel share outbound connections and can
// fail due to other messages failing on the same channel
bool canRetry = (this.channelExtension.ReceiveContextEnabled || !this.channelExtension.TransactedReceiveEnabled);
if (canRetry && !this.abortedRetry)
{
//No session and ReceiveContext or non transactional, retry the message 1 time (before moving to backup)
this.abortedRetry = true;
this.ResetState();
return(true);
}
}
else if (e is EndpointNotFoundException)
{
// The channel may not fault for this exception for bindings other than netTcpBinding
// We abort the channel in that case. We proactively clean up so that we don't have to cleanup later
SessionChannels sessionChannels = this.service.GetSessionChannels(messageRpc.Impersonating);
if (sessionChannels != null)
{
sessionChannels.AbortChannel(sendOperation.CurrentEndpoint);
}
}
else if (e is MessageSecurityException)
{
// The service may have been stopped and restarted without the routing service knowledge.
// When we try to use a cached channel to the service, the channel can fault due to this exception
// The faulted channel gets cleaned up and we retry one more time only when service has backup
// If there is no backup, we do not retry since we do not create a buffered message to prevent performance degradation
if (!this.abortedRetry && (sendOperation.AlternateEndpointCount > 0))
{
this.abortedRetry = true;
this.ResetState();
return(true);
}
}
if (sendOperation.TryMoveToAlternate(e))
{
if (TD.RoutingServiceMovedToBackupIsEnabled())
{
TD.RoutingServiceMovedToBackup(messageRpc.EventTraceActivity, messageRpc.UniqueID, this.destinationIndex.ToString(TD.Culture), sendOperation.CurrentEndpoint.ToString());
}
this.ResetState();
canHandle = true;
}
else if (this.service.GetTransactionForSending(messageRpc) == null)
{
// This is OneWay with no Transaction...
// store this exception for when we complete, but continue any multicasting
this.service.SessionException = e;
// Mark the SendOperation as 'Sent' because there's no more work we can do (non-tx and no more backups)
sendOperation.TransmitSucceeded(null);
if (this.channelExtension.HasSession)
{
this.channelExtension.SessionChannels.AbortChannel(this.client.Key);
}
this.MoveToNextClientOperation(messageRpc.Operations.Count);
canHandle = true;
}
else
{
canHandle = false;
}
return(canHandle);
}
bool SendToCurrentClient()
{
MessageRpc messageRpc = this.service.SessionMessages[this.sessionMessageIndex];
SendOperation sendOperation = messageRpc.Operations[this.destinationIndex];
if (sendOperation.Sent)
{
this.MoveToNextClientOperation(messageRpc.Operations.Count);
return(true);
}
else if (!this.channelExtension.ReceiveContextEnabled &&
this.channelExtension.TransactedReceiveEnabled &&
sendOperation.HasAlternate)
{
// We can't do error handling for oneway Transactional unless there's RC.
throw FxTrace.Exception.AsError(new ConfigurationErrorsException(SR.ErrorHandlingNotSupportedTxNoRC(messageRpc.OperationContext.Channel.LocalAddress)));
}
RoutingEndpointTrait endpointTrait = sendOperation.CurrentEndpoint;
this.client = this.service.GetOrCreateClient <TContract>(endpointTrait, messageRpc.Impersonating);
try
{
// We always work on cloned message when there are backup endpoints to handle exception cases
Message message;
if (messageRpc.Operations.Count == 1 && sendOperation.AlternateEndpointCount == 0)
{
message = messageRpc.Message;
}
else
{
message = messageRpc.CreateBuffer().CreateMessage();
}
sendOperation.PrepareMessage(message);
IAsyncResult result;
if (TD.RoutingServiceTransmittingMessageIsEnabled())
{
TD.RoutingServiceTransmittingMessage(messageRpc.EventTraceActivity, messageRpc.UniqueID, this.destinationIndex.ToString(TD.Culture), this.client.Key.ToString());
}
Transaction transaction = this.service.GetTransactionForSending(messageRpc);
using (this.PrepareTransactionalCall(transaction))
{
IDisposable impersonationContext = null;
try
{
//Perform the assignment in a finally block so it won't be interrupted asynchronously
try { }
finally
{
impersonationContext = messageRpc.PrepareCall();
}
result = this.client.BeginOperation(message, transaction, this.PrepareAsyncCompletion(clientOperationCallback), this);
}
finally
{
if (impersonationContext != null)
{
impersonationContext.Dispose();
}
}
}
if (this.CheckSyncContinue(result))
{
this.ClientOperationComplete(result);
return(true);
}
else
{
return(false);
}
}
catch (Exception exception)
{
if (Fx.IsFatal(exception))
{
throw;
}
//See if we can handle this Exception...
if (this.HandleClientOperationFailure(exception))
{
return(true);
}
throw;
}
}
void SerializeOutputs(ref MessageRpc rpc)
{
if (!this.IsOneWay && this.parent.EnableFaults)
{
Message reply;
if (this.serializeReply)
{
try
{
if (TD.DispatchFormatterSerializeReplyStartIsEnabled())
{
TD.DispatchFormatterSerializeReplyStart(rpc.EventTraceActivity);
}
bool outputTiming = DS.MessageFormatterIsEnabled();
Stopwatch sw = null;
if (outputTiming)
{
sw = Stopwatch.StartNew();
}
reply = this.Formatter.SerializeReply(rpc.RequestVersion, rpc.OutputParameters, rpc.ReturnParameter);
if (outputTiming)
{
DS.DispatchMessageFormatterSerialize(this.Formatter.GetType(), sw.Elapsed);
}
if (TD.DispatchFormatterSerializeReplyStopIsEnabled())
{
TD.DispatchFormatterSerializeReplyStop(rpc.EventTraceActivity);
}
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
if (ErrorBehavior.ShouldRethrowExceptionAsIs(e))
{
throw;
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperCallback(e);
}
if (reply == null)
{
string message = SR.GetString(SR.SFxNullReplyFromFormatter2, this.Formatter.GetType().ToString(), (this.name ?? ""));
ErrorBehavior.ThrowAndCatch(new InvalidOperationException(message));
}
}
else
{
if ((rpc.ReturnParameter == null) && (rpc.OperationContext.RequestContext != null))
{
string message = SR.GetString(SR.SFxDispatchRuntimeMessageCannotBeNull, this.name);
ErrorBehavior.ThrowAndCatch(new InvalidOperationException(message));
}
reply = (Message)rpc.ReturnParameter;
if ((reply != null) && (!ProxyOperationRuntime.IsValidAction(reply, this.ReplyAction)))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxInvalidReplyAction, this.Name, reply.Headers.Action ?? "{NULL}", this.ReplyAction)));
}
}
if (DiagnosticUtility.ShouldUseActivity && rpc.Activity != null && reply != null)
{
TraceUtility.SetActivity(reply, rpc.Activity);
if (TraceUtility.ShouldPropagateActivity)
{
TraceUtility.AddActivityHeader(reply);
}
}
else if (TraceUtility.ShouldPropagateActivity && reply != null && rpc.ResponseActivityId != Guid.Empty)
{
ActivityIdHeader header = new ActivityIdHeader(rpc.ResponseActivityId);
header.AddTo(reply);
}
//rely on the property set during the message receive to correlate the trace
if (TraceUtility.MessageFlowTracingOnly)
{
//Guard against MEX scenarios where the message is closed by now
if (null != rpc.OperationContext.IncomingMessage && MessageState.Closed != rpc.OperationContext.IncomingMessage.State)
{
FxTrace.Trace.SetAndTraceTransfer(TraceUtility.GetReceivedActivityId(rpc.OperationContext), true);
}
else
{
if (rpc.ResponseActivityId != Guid.Empty)
{
FxTrace.Trace.SetAndTraceTransfer(rpc.ResponseActivityId, true);
}
}
}
// Add the ImpersonateOnSerializingReplyMessageProperty on the reply message iff
// a. reply message is not null.
// b. Impersonation is enabled on serializing Reply
if (reply != null && this.parent.IsImpersonationEnabledOnSerializingReply)
{
bool shouldImpersonate = this.parent.SecurityImpersonation != null && this.parent.SecurityImpersonation.IsImpersonationEnabledOnCurrentOperation(ref rpc);
if (shouldImpersonate)
{
reply.Properties.Add(ImpersonateOnSerializingReplyMessageProperty.Name, new ImpersonateOnSerializingReplyMessageProperty(ref rpc));
reply = new ImpersonatingMessage(reply);
}
}
if (MessageLogger.LoggingEnabled && null != reply)
{
MessageLogger.LogMessage(ref reply, MessageLoggingSource.ServiceLevelSendReply | MessageLoggingSource.LastChance);
}
rpc.Reply = reply;
}
}
/// <summary>
/// Constructs the object with all of the environments primary controls.
/// </summary>
/// <param name="qSetExplorer">Primary QSetExplorer.</param>
/// <param name="qSetMonitor">Primary QSetMonitor.</param>
/// <param name="propertyGrid">Primary property grid.</param>
/// <param name="messageViewer">Primary MessageViewer.</param>
/// <param name="documentContainer">Primary DocumentContainer.</param>
/// <param name="images">Images component.</param>
public PrimaryControls(
QSetExplorer qSetExplorer,
QSetMonitor qSetMonitor,
PropertyGrid propertyGrid,
MessageViewer messageViewer,
TD.SandDock.DocumentContainer documentContainer,
Images images)
{
_qSetExplorer = qSetExplorer;
_qSetMonitor = qSetMonitor;
_propertyGrid = propertyGrid;
_messageViewer = messageViewer;
_documentContainer = documentContainer;
_images = images;
_messageBrowserCollection = new MessageBrowserCollection();
_webServiceClientControlCollection = new WebServiceClientControlCollection();
}
public void Authorize(ref MessageRpc rpc)
{
if (TD.DispatchMessageBeforeAuthorizationIsEnabled())
{
TD.DispatchMessageBeforeAuthorization(rpc.EventTraceActivity);
}
SecurityMessageProperty security = SecurityMessageProperty.GetOrCreate(rpc.Request);
security.ExternalAuthorizationPolicies = this.externalAuthorizationPolicies;
ServiceAuthorizationManager serviceAuthorizationManager = this.serviceAuthorizationManager ?? DefaultServiceAuthorizationManager;
bool outputTiming = DS.AuthorizationIsEnabled();
Stopwatch sw = null;
if (outputTiming)
{
sw = Stopwatch.StartNew();
}
try
{
if (!serviceAuthorizationManager.CheckAccess(rpc.OperationContext, ref rpc.Request))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateAccessDeniedFaultException());
}
if (outputTiming)
{
DS.Authorization(this.serviceAuthorizationManager.GetType(), true, sw.Elapsed);
}
}
catch (Exception ex)
{
if (Fx.IsFatal(ex))
{
throw;
}
if (outputTiming)
{
DS.Authorization(this.serviceAuthorizationManager.GetType(), false, sw.Elapsed);
}
if (PerformanceCounters.PerformanceCountersEnabled)
{
PerformanceCounters.AuthorizationFailed(rpc.Operation.Name);
}
if (AuditLevel.Failure == (this.serviceAuthorizationAuditLevel & AuditLevel.Failure))
{
try
{
string primaryIdentity;
string authContextId = null;
AuthorizationContext authContext = security.ServiceSecurityContext.AuthorizationContext;
if (authContext != null)
{
primaryIdentity = SecurityUtils.GetIdentityNamesFromContext(authContext);
authContextId = authContext.Id;
}
else
{
primaryIdentity = SecurityUtils.AnonymousIdentity.Name;
authContextId = "<null>";
}
SecurityAuditHelper.WriteServiceAuthorizationFailureEvent(this.auditLogLocation,
this.suppressAuditFailure, rpc.Request, rpc.Request.Headers.To, rpc.Request.Headers.Action,
primaryIdentity, authContextId,
serviceAuthorizationManager == DefaultServiceAuthorizationManager ? "<default>" : serviceAuthorizationManager.GetType().Name,
ex);
}
#pragma warning suppress 56500
catch (Exception auditException)
{
if (Fx.IsFatal(auditException))
{
throw;
}
DiagnosticUtility.TraceHandledException(auditException, TraceEventType.Error);
}
}
throw;
}
if (AuditLevel.Success == (this.serviceAuthorizationAuditLevel & AuditLevel.Success))
{
string primaryIdentity;
string authContextId;
AuthorizationContext authContext = security.ServiceSecurityContext.AuthorizationContext;
if (authContext != null)
{
primaryIdentity = SecurityUtils.GetIdentityNamesFromContext(authContext);
authContextId = authContext.Id;
}
else
{
primaryIdentity = SecurityUtils.AnonymousIdentity.Name;
authContextId = "<null>";
}
SecurityAuditHelper.WriteServiceAuthorizationSuccessEvent(this.auditLogLocation,
this.suppressAuditFailure, rpc.Request, rpc.Request.Headers.To, rpc.Request.Headers.Action,
primaryIdentity, authContextId,
serviceAuthorizationManager == DefaultServiceAuthorizationManager ? "<default>" : serviceAuthorizationManager.GetType().Name);
}
}
public IAsyncResult InvokeBegin(object instance, object[] inputs, AsyncCallback callback, object state)
{
IAsyncResult result;
if (instance == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("SFxNoServiceObject")));
}
if (inputs == null)
{
if (this.InputParameterCount > 0)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("SFxInputParametersToServiceNull", new object[] { this.InputParameterCount })));
}
}
else if (inputs.Length != this.InputParameterCount)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("SFxInputParametersToServiceInvalid", new object[] { this.InputParameterCount, inputs.Length })));
}
if (PerformanceCounters.PerformanceCountersEnabled)
{
PerformanceCounters.MethodCalled(this.beginMethod.Name.Substring("Begin".Length));
}
try
{
ServiceModelActivity activity = null;
Activity boundActivity = null;
this.CreateActivityInfo(ref activity, ref boundActivity);
if (TD.OperationInvokedIsEnabled())
{
TD.OperationInvoked(this.beginMethod.Name.Substring("Begin".Length), TraceUtility.GetCallerInfo(OperationContext.Current));
}
if ((TD.OperationCompletedIsEnabled() || TD.OperationFaultedIsEnabled()) || TD.OperationFailedIsEnabled())
{
TraceUtility.UpdateAsyncOperationContextWithStartTime(DateTime.UtcNow.Ticks);
}
using (boundActivity)
{
if (DiagnosticUtility.ShouldUseActivity)
{
string activityName = null;
if (this.endMethod == null)
{
activityName = System.ServiceModel.SR.GetString("ActivityExecuteMethod", new object[] { this.beginMethod.DeclaringType.FullName, this.beginMethod.Name });
}
else
{
activityName = System.ServiceModel.SR.GetString("ActivityExecuteAsyncMethod", new object[] { this.beginMethod.DeclaringType.FullName, this.beginMethod.Name, this.endMethod.DeclaringType.FullName, this.endMethod.Name });
}
ServiceModelActivity.Start(activity, activityName, ActivityType.ExecuteUserCode);
}
result = this.InvokeBeginDelegate(instance, inputs, callback, state);
}
ServiceModelActivity.Stop(activity);
}
catch (SecurityException exception)
{
DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Warning);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(AuthorizationBehavior.CreateAccessDeniedFaultException());
}
catch (Exception exception2)
{
TraceUtility.TraceUserCodeException(exception2, this.beginMethod);
throw;
}
return(result);
}
private void ContextMenu_BeforePopup(object sender, TD.SandBar.MenuPopupEventArgs e) {
try {
TreeNode treeNode = this.treeView1.SelectedNode;
this.menuButtonItemScroll.Enabled = (treeNode is TreeNodeTable);
this.menuButtonItemFlash.Enabled = (treeNode is TreeNodeTable);
}
catch (Exception ex) {
ExceptionDialog.HandleException(ex);
}
}
static public void LeftClickMenu(Rect rect, TC_ItemBehaviour item)
{
if (TD.ClickRect(rect) != 1)
{
return;
}
string itemText = "";
if (item.GetType() == typeof(TC_SelectItem))
{
itemText = "Item";
}
else
{
itemText = "Node";
}
GenericMenu menu = new GenericMenu();
string instanceID = item.GetInstanceID().ToString();
if (Event.current.mousePosition.x < rect.x + ((TD.texCardHeader.width / 2) * TD.scale))
{
menu.AddItem(new GUIContent("<-- Add " + itemText), false, LeftClickMenu, instanceID + ":Add Left");
//if (itemText == "Node")
//{
// menu.AddItem(new GUIContent("<-- Add Node Group"), false, LeftClickMenu, instanceID + ":Add NodeGroup Left");
// menu.AddSeparator("");
//}
menu.AddItem(new GUIContent("<-- Duplicate " + itemText), false, LeftClickMenu, instanceID + ":Duplicate Left");
}
else
{
menu.AddItem(new GUIContent("--> Add " + itemText), false, LeftClickMenu, instanceID + ":Add Right");
//if (itemText == "Node")
//{
// menu.AddItem(new GUIContent("--> Add Node Group"), false, LeftClickMenu, instanceID + ":Add NodeGroup Right");
// menu.AddSeparator("");
//}
menu.AddItem(new GUIContent("--> Duplicate " + itemText), false, LeftClickMenu, instanceID + ":Duplicate Right");
}
// bool eraseNodeMenu = true;
//if (node.nodeType == NodeType.Select)
//{
// TC_NodeGroup nodeGroup = node.t.parent.GetComponent<TC_NodeGroup>();
// if (nodeGroup != null)
// {
// if (nodeGroup.itemList.Count == 1) eraseNodeMenu = false;
// }
//}
//if (eraseNodeMenu) {
// menu.AddSeparator("");
// menu.AddItem(new GUIContent("Erase Node"), false, LeftClickMenu, instanceID + ":Erase Node");
//}
menu.ShowAsContext();
}
private ButtonItem AddTool(TD.SandBar.ToolBar toolbar, IToolBase tool, Keys shortcut)
{
ButtonItem buttonItem = new ButtonItem();
buttonItem.Image = tool.GetToolImage();
buttonItem.ToolTipText = StringUtils.EscapeUIString(tool.GetToolName()) + ((shortcut != Keys.None) ? (" (" + shortcut.ToString() + ")") : "");
buttonItem.Tag = tool;
if (tool is ITool)
{
buttonItem.Activate += new EventHandler(this.tool_Activate);
}
else
{
if (tool is IToolAction)
{
buttonItem.Activate += new EventHandler(this.toolBase_Activate);
}
}
toolbar.Items.Add(buttonItem);
this.m_toolItemList.Add(buttonItem);
if (shortcut != Keys.None)
{
this.m_toolShortcuts.Add(shortcut, buttonItem);
}
return buttonItem;
}
/// <summary>
/// Form closing event.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Roles_Closing(object sender, TD.SandDock.DockControlClosingEventArgs e)
{
if (this.FormChanged)
{
if (MessageBox.Show("Do you wish to save your changes first?",
"Question", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
{
SaveRecord();
}
}
}
private TD.SandBar.ToolBar CreateToolbar(string id, string text, int row, TD.SandBar.ToolBar afterToolbar)
{
TD.SandBar.ToolBar toolBar = new TD.SandBar.ToolBar();
toolBar.Guid = new Guid(id.GetHashCode(), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
toolBar.DockLine = row;
toolBar.DockOffset = afterToolbar.DockOffset + afterToolbar.Width;
this.sandBarManager.AddToolbar(toolBar);
toolBar.Redock(this.sandBarManager.FindSuitableContainer(DockStyle.Top));
toolBar.Text = text;
return toolBar;
}
private void toolBarTopicName_ButtonClick(object sender, TD.SandBar.ToolBarItemEventArgs e)
{
if (e.Item == buttonItemSave)
{
string attribution = (comboBoxAttribution.ComboBox.Text == "") ? comboBoxAttribution.DefaultText : comboBoxAttribution.ComboBox.Text;
editService.SetTextForTopic((AbsoluteTopicName)listViewTopicNames.SelectedItems[0].Tag, richTextBox1.Text, attribution);
// reload the version list and refresh the Preview and Text tabs.
LoadTopic((AbsoluteTopicName)listViewTopicNames.SelectedItems[0].Tag);
}
else if (e.Item == buttonItemRestore)
{
if (flatComboBoxVersion.SelectedIndex > 0)
{
// restore the topic to a previous version
string version = flatComboBoxVersion.SelectedItem.ToString();
string attribution = (comboBoxAttribution.ComboBox.Text == "") ? comboBoxAttribution.DefaultText : comboBoxAttribution.ComboBox.Text;
editService.RestoreTopic((AbsoluteTopicName)listViewTopicNames.SelectedItems[0].Tag, attribution, version);
// reload the version list and refresh the Preview and Text tabs.
LoadTopic((AbsoluteTopicName)listViewTopicNames.SelectedItems[0].Tag);
}
}
}
internal void AfterReply(ref ProxyRpc rpc)
{
if (!this.isOneWay)
{
Message reply = rpc.Reply;
if (this.deserializeReply)
{
if (TD.ClientFormatterDeserializeReplyStartIsEnabled())
{
TD.ClientFormatterDeserializeReplyStart(rpc.EventTraceActivity);
}
bool outputTiming = DS.MessageFormatterIsEnabled();
Stopwatch sw = null;
if (outputTiming)
{
sw = Stopwatch.StartNew();
}
rpc.ReturnValue = this.formatter.DeserializeReply(reply, rpc.OutputParameters);
if (outputTiming)
{
DS.ClientMessageFormatterDeserialize(this.formatter.GetType(), sw.Elapsed);
}
if (TD.ClientFormatterDeserializeReplyStopIsEnabled())
{
TD.ClientFormatterDeserializeReplyStop(rpc.EventTraceActivity);
}
}
else
{
rpc.ReturnValue = reply;
}
int offset = this.parent.ParameterInspectorCorrelationOffset;
try
{
bool outputTiming = DS.ParameterInspectorIsEnabled();
Stopwatch sw = null;
if (outputTiming)
{
sw = new Stopwatch();
}
for (int i = parameterInspectors.Length - 1; i >= 0; i--)
{
if (outputTiming)
{
sw.Restart();
}
this.parameterInspectors[i].AfterCall(this.name,
rpc.OutputParameters,
rpc.ReturnValue,
rpc.Correlation[offset + i]);
if (outputTiming)
{
DS.ParameterInspectorAfter(this.parameterInspectors[i].GetType(), sw.Elapsed);
}
if (TD.ClientParameterInspectorAfterCallInvokedIsEnabled())
{
TD.ClientParameterInspectorAfterCallInvoked(rpc.EventTraceActivity, this.parameterInspectors[i].GetType().FullName);
}
}
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
if (ErrorBehavior.ShouldRethrowClientSideExceptionAsIs(e))
{
throw;
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperCallback(e);
}
if (parent.ValidateMustUnderstand)
{
Collection <MessageHeaderInfo> headersNotUnderstood = reply.Headers.GetHeadersNotUnderstood();
if (headersNotUnderstood != null && headersNotUnderstood.Count > 0)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ProtocolException(SR.GetString(SR.SFxHeaderNotUnderstood, headersNotUnderstood[0].Name, headersNotUnderstood[0].Namespace)));
}
}
}
}
void DrawMenu()
{
TC_Settings settings = TC_Settings.instance;
float width = 55;
GUI.color = EditorGUIUtility.isProSkin ? new Color(0.2f, 0.2f, 0.2f) : new Color(0.5f, 0.5f, 0.5f);
GUI.DrawTexture(new Rect(0, 0, TC_NodeWindow.window.position.width, 20), Texture2D.whiteTexture);
GUI.color = Color.white;
EditorGUILayout.BeginHorizontal();
if (!TC_Settings.instance.hideMenuBar)
{
GUILayout.Space(2);
if (GUILayout.Button("File", EditorStyles.miniButtonMid, GUILayout.Width(width)))
{
GenericMenu menu = new GenericMenu();
DrawFile(menu, false);
menu.DropDown(new Rect(1, 17, 1, 1));
}
if (GUILayout.Button("Options", EditorStyles.miniButtonMid, GUILayout.Width(width)))
{
GenericMenu menu = new GenericMenu();
DrawOptions(menu, false);
menu.DropDown(new Rect(1 + width, 17, 1, 1));
}
if (GUILayout.Button("Help", EditorStyles.miniButtonMid, GUILayout.Width(width)))
{
GenericMenu menu = new GenericMenu();
DrawHelp(menu, false);
menu.DropDown(new Rect(1 + width * 2, 17, 1, 1));
}
if (!TC_Settings.instance.global.documentationClicked)
{
GUI.color = new Color(Mathf.Abs(Mathf.Sin(Time.realtimeSinceStartup)), Mathf.Abs(Mathf.Cos(Time.realtimeSinceStartup)), 0);
}
else
{
GUI.color = Color.white;
}
if (GUILayout.Button("Documentation", EditorStyles.miniButtonMid, GUILayout.Width(width + 40)))
{
if (Event.current.shift)
{
TC_Settings.instance.global.documentationClicked = false;
}
else
{
TC_Settings.instance.global.documentationClicked = true;
Application.OpenURL("http://www.terraincomposer.com/terraincomposer2-documentation/");
}
}
GUI.color = Color.white;
GUILayout.Space(TC_NodeWindow.window.position.width - 620 - ((width * 2) + 45));
}
else
{
GUILayout.Space(TC_NodeWindow.window.position.width - 449 - (width + 5));
}
GUI.changed = false;
float labelWidthOld = EditorGUIUtility.labelWidth;
EditorGUIUtility.labelWidth = 45;
settings.seed = EditorGUILayout.FloatField("Seed", settings.seed, GUILayout.Width(100));
if (GUILayout.Button("Random", EditorStyles.miniButtonMid, GUILayout.Width(50)))
{
if (eventCurrent.control)
{
TC_Settings.instance.seed = 0;
}
else
{
float oldSeed;
do
{
oldSeed = TC_Settings.instance.seed;
TC_Settings.instance.seed = Random.Range(-20000.0f, 20000.0f);
}while (oldSeed == TC_Settings.instance.seed);
}
GUI.changed = true;
}
if (GUI.changed)
{
EditorUtility.SetDirty(settings);
TC.AutoGenerate();
}
GUILayout.Space(20);
EditorGUIUtility.labelWidth = labelWidthOld;
for (int i = 0; i < 6; i++)
{
TC_LayerGroup layerGroup = terrainLayer.layerGroups[i];
if (layerGroup == null)
{
break;
}
if (layerGroup.visible)
{
if (layerGroup.active)
{
GUI.backgroundColor = Color.green;
}
else
{
GUI.backgroundColor = Color.red;
}
}
if (GUILayout.Button(TC.outputNames[i][0].ToString(), EditorStyles.miniButtonMid, GUILayout.Width(25)))
{
if (eventCurrent.control)
{
settings.scrollOffset = -layerGroup.nodePos;
}
else
{
TD.ClickOutputButton(layerGroup);
}
}
GUI.backgroundColor = Color.white;
}
GUILayout.Space(5);
if (GUILayout.Button("Generate", EditorStyles.miniButtonMid, GUILayout.Width(width + 5)))
{
ClickMenuMain("Generate");
}
if (TC_Generate.instance.autoGenerate)
{
GUI.backgroundColor = Color.green;
}
else if (TC.autoGenerateCallTimeStart + 0.05f > Time.realtimeSinceStartup)
{
GUI.backgroundColor = Color.red;
}
if (GUILayout.Button("Auto", EditorStyles.miniButtonMid, GUILayout.Width(width)))
{
ClickMenuMain("Auto Generate");
}
GUI.backgroundColor = Color.white;
if (GUILayout.Button("Refresh", EditorStyles.miniButtonMid, GUILayout.Width(width)))
{
ClickMenuMain("Refresh");
}
EditorGUILayout.EndHorizontal();
}
internal void BeforeRequest(ref ProxyRpc rpc)
{
int offset = this.parent.ParameterInspectorCorrelationOffset;
try
{
bool outputTiming = DS.ParameterInspectorIsEnabled();
Stopwatch sw = null;
if (outputTiming)
{
sw = new Stopwatch();
}
for (int i = 0; i < parameterInspectors.Length; i++)
{
if (outputTiming)
{
sw.Restart();
}
rpc.Correlation[offset + i] = this.parameterInspectors[i].BeforeCall(this.name, rpc.InputParameters);
if (outputTiming)
{
DS.ParameterInspectorBefore(this.parameterInspectors[i].GetType(), sw.Elapsed);
}
if (TD.ClientParameterInspectorBeforeCallInvokedIsEnabled())
{
TD.ClientParameterInspectorBeforeCallInvoked(rpc.EventTraceActivity, this.parameterInspectors[i].GetType().FullName);
}
}
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
if (ErrorBehavior.ShouldRethrowClientSideExceptionAsIs(e))
{
throw;
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperCallback(e);
}
if (this.serializeRequest)
{
if (TD.ClientFormatterSerializeRequestStartIsEnabled())
{
TD.ClientFormatterSerializeRequestStart(rpc.EventTraceActivity);
}
bool outputTiming = DS.MessageFormatterIsEnabled();
Stopwatch sw = null;
if (outputTiming)
{
sw = Stopwatch.StartNew();
}
rpc.Request = this.formatter.SerializeRequest(rpc.MessageVersion, rpc.InputParameters);
if (outputTiming)
{
DS.ClientMessageFormatterSerialize(this.formatter.GetType(), sw.Elapsed);
}
if (TD.ClientFormatterSerializeRequestStopIsEnabled())
{
TD.ClientFormatterSerializeRequestStop(rpc.EventTraceActivity);
}
}
else
{
if (rpc.InputParameters[0] == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxProxyRuntimeMessageCannotBeNull, this.name)));
}
rpc.Request = (Message)rpc.InputParameters[0];
if (!IsValidAction(rpc.Request, Action))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxInvalidRequestAction, this.Name, rpc.Request.Headers.Action ?? "{NULL}", this.Action)));
}
}
}
private void TextChanged(object sender, TextChangedEventArgs e)
{
if (!b_changing)
{
b_changing = true;
TextBox text = sender as TextBox;
int i, j;
int.TryParse(text.Name.Last().ToString(), out j);
int.TryParse(text.Name[text.Name.Count() - 2].ToString(), out i);
double TD, d;
int fr;
double ab, bed, eqd2;
if (j < 3)
{
if (last >= 0)
{
if (current != 0 && last != 0)
{
if (int.TryParse(textFraction[i].Text, out fr))
{
if (double.TryParse(textDose1fr[i].Text, out d))
{
if (double.TryParse(textAlphaBeta[i].Text, out ab))
{
TD = d * fr;
totaldose[i] = TD / scrollBar.Value * 100;
textTotalDose[i].Text = TD.ToString();
bed = TD * (1 + d / ab);
textBED[i].Text = bed.ToString();
eqd2 = TD * (d + ab) / (2 + ab);
textEQD2[i].Text = eqd2.ToString();
}
}
}
}
else if (current != 1 && last != 1)
{
if (double.TryParse(textTotalDose[i].Text, out TD))
{
if (double.TryParse(textDose1fr[i].Text, out d))
{
if (double.TryParse(textAlphaBeta[i].Text, out ab))
{
totaldose[i] = TD / scrollBar.Value * 100;
fr = (int)Math.Round(TD / d);
textFraction[i].Text = fr.ToString();
bed = TD * (1 + d / ab);
textBED[i].Text = bed.ToString();
eqd2 = TD * (d + ab) / (2 + ab);
textEQD2[i].Text = eqd2.ToString();
}
}
}
}
else if (current != 2 && last != 2)
{
if (double.TryParse(textTotalDose[i].Text, out TD))
{
if (int.TryParse(textFraction[i].Text, out fr))
{
if (double.TryParse(textAlphaBeta[i].Text, out ab))
{
totaldose[i] = TD / scrollBar.Value * 100;
d = TD / fr;
textDose1fr[i].Text = d.ToString();
bed = TD * (1 + d / ab);
textBED[i].Text = bed.ToString();
eqd2 = TD * (d + ab) / (2 + ab);
textEQD2[i].Text = eqd2.ToString();
}
}
}
}
}
}
if (j == 3)
{
if (double.TryParse(textTotalDose[i].Text, out TD))
{
if (int.TryParse(textFraction[i].Text, out fr))
{
if (double.TryParse(textDose1fr[i].Text, out d))
{
if (double.TryParse(textAlphaBeta[i].Text, out ab))
{
TD = totaldose[i] * scrollBar.Value / 100;
textTotalDose[i].Text = TD.ToString();
d = TD / fr;
textDose1fr[i].Text = d.ToString();
bed = TD * (1 + d / ab);
textBED[i].Text = bed.ToString();
eqd2 = TD * (d + ab) / (2 + ab);
textEQD2[i].Text = eqd2.ToString();
}
}
}
}
}
if (j > 3)
{
if (int.TryParse(textFraction[i].Text, out fr))
{
if (double.TryParse(textAlphaBeta[i].Text, out ab))
{
if (j == 4)
{
if (double.TryParse(textBED[i].Text, out bed))
{
d = (-fr + Math.Sqrt(fr * fr + 4 * fr / ab * bed)) / (2 * fr / ab);
textDose1fr[i].Text = d.ToString();
TD = d * fr;
totaldose[i] = TD / scrollBar.Value * 100;
textTotalDose[i].Text = TD.ToString();
eqd2 = TD * (d + ab) / (2 + ab);
textEQD2[i].Text = eqd2.ToString();
}
}
if (j == 5)
{
if (double.TryParse(textEQD2[i].Text, out eqd2))
{
d = (-fr * ab + Math.Sqrt(fr * ab * fr * ab + 4 * fr * eqd2 * (2 + ab))) / (2 * fr);
textDose1fr[i].Text = d.ToString();
TD = d * fr;
totaldose[i] = TD / scrollBar.Value * 100;
textTotalDose[i].Text = TD.ToString();
bed = TD * (1 + d / ab);
textBED[i].Text = bed.ToString();
}
}
}
}
}
Sum();
b_changing = false;
}
}
public void ObjectValue(TD d)
{
CollectionAssert.IsNotEmpty(d.JSON);
object o = JsonConvert.DeserializeObject(d.JSON, d.Type, _jss);
Assert.IsNotNull(o);
foreach(string k in d.Expected.Keys)
{
PropertyInfo p = p = d.Type.GetProperty(k, BindingFlags.Public | BindingFlags.Instance);
Assert.IsNotNull(p);
Assert.IsTrue(p.CanRead);
object v = p.GetValue(o);
Assert.AreEqual(d.Expected[k], v);
}
}
void DeserializeInputs(ref MessageRpc rpc)
{
bool success = false;
try
{
try
{
rpc.InputParameters = this.Invoker.AllocateInputs();
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
if (ErrorBehavior.ShouldRethrowExceptionAsIs(e))
{
throw;
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperCallback(e);
}
try
{
// If the field is true, then this operation is to be invoked at the time the service
// channel is opened. The incoming message is created at ChannelHandler level with no
// content, so we don't need to deserialize the message.
if (!this.isSessionOpenNotificationEnabled)
{
if (this.deserializeRequest)
{
if (TD.DispatchFormatterDeserializeRequestStartIsEnabled())
{
TD.DispatchFormatterDeserializeRequestStart(rpc.EventTraceActivity);
}
bool outputTiming = DS.MessageFormatterIsEnabled();
Stopwatch sw = null;
if (outputTiming)
{
sw = Stopwatch.StartNew();
}
this.Formatter.DeserializeRequest(rpc.Request, rpc.InputParameters);
if (outputTiming)
{
DS.DispatchMessageFormatterDeserialize(this.Formatter.GetType(), sw.Elapsed);
}
if (TD.DispatchFormatterDeserializeRequestStopIsEnabled())
{
TD.DispatchFormatterDeserializeRequestStop(rpc.EventTraceActivity);
}
}
else
{
rpc.InputParameters[0] = rpc.Request;
}
}
success = true;
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
if (ErrorBehavior.ShouldRethrowExceptionAsIs(e))
{
throw;
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperCallback(e);
}
}
finally
{
rpc.DidDeserializeRequestBody = (rpc.Request.State != MessageState.Created);
if (!success && MessageLogger.LoggingEnabled)
{
MessageLogger.LogMessage(ref rpc.Request, MessageLoggingSource.Malformed);
}
}
}
private async Task <Tuple <object, object[]> > InvokeAsync(object instance, object[] inputs)
{
EnsureIsInitialized();
if (instance == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new InvalidOperationException(SR.SFxNoServiceObject));
}
if (inputs == null)
{
if (_inputParameterCount > 0)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new InvalidOperationException(SR.Format(SR.SFxInputParametersToServiceNull, _inputParameterCount)));
}
}
else if (inputs.Length != _inputParameterCount)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new InvalidOperationException(SR.Format(SR.SFxInputParametersToServiceInvalid, _inputParameterCount,
inputs.Length)));
}
var outputs = EmptyArray <object> .Allocate(_outputParameterCount);
long beginOperation = 0;
bool callSucceeded = false;
bool callFaulted = false;
EventTraceActivity eventTraceActivity = null;
if (TD.OperationCompletedIsEnabled() ||
TD.OperationFaultedIsEnabled() ||
TD.OperationFailedIsEnabled())
{
beginOperation = DateTime.UtcNow.Ticks;
OperationContext context = OperationContext.Current;
if (context != null && context.IncomingMessage != null)
{
eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(context.IncomingMessage);
}
}
object returnValue;
try
{
ServiceModelActivity activity = null;
IDisposable boundActivity = null;
if (DiagnosticUtility.ShouldUseActivity)
{
activity = ServiceModelActivity.CreateBoundedActivity(true);
boundActivity = activity;
}
else if (TraceUtility.MessageFlowTracingOnly)
{
Guid activityId = TraceUtility.GetReceivedActivityId(OperationContext.Current);
if (activityId != Guid.Empty)
{
DiagnosticTraceBase.ActivityId = activityId;
}
}
else if (TraceUtility.ShouldPropagateActivity)
{
//Message flow tracing only scenarios use a light-weight ActivityID management logic
Guid activityId = ActivityIdHeader.ExtractActivityId(OperationContext.Current.IncomingMessage);
if (activityId != Guid.Empty)
{
boundActivity = Activity.CreateActivity(activityId);
}
}
using (boundActivity)
{
if (DiagnosticUtility.ShouldUseActivity)
{
ServiceModelActivity.Start(activity,
SR.Format(SR.ActivityExecuteMethod, _taskMethod.DeclaringType.FullName, _taskMethod.Name),
ActivityType.ExecuteUserCode);
}
if (TD.OperationInvokedIsEnabled())
{
TD.OperationInvoked(eventTraceActivity, MethodName,
TraceUtility.GetCallerInfo(OperationContext.Current));
}
returnValue = _invokeDelegate(instance, inputs, outputs);
if (returnValue == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("task");
}
var returnValueTask = returnValue as Task;
if (returnValueTask != null)
{
// Only return once the task has completed
await returnValueTask;
}
callSucceeded = true;
}
}
catch (FaultException)
{
callFaulted = true;
throw;
}
finally
{
if (beginOperation != 0)
{
if (callSucceeded)
{
if (TD.OperationCompletedIsEnabled())
{
TD.OperationCompleted(eventTraceActivity, _methodName,
TraceUtility.GetUtcBasedDurationForTrace(beginOperation));
}
}
else if (callFaulted)
{
if (TD.OperationFaultedIsEnabled())
{
TD.OperationFaulted(eventTraceActivity, _methodName,
TraceUtility.GetUtcBasedDurationForTrace(beginOperation));
}
}
else
{
if (TD.OperationFailedIsEnabled())
{
TD.OperationFailed(eventTraceActivity, _methodName,
TraceUtility.GetUtcBasedDurationForTrace(beginOperation));
}
}
}
}
return(Tuple.Create(returnValue, outputs));
}
internal Message MarshalMessage(Message source, Uri to, MessageVersion targetVersion)
{
Message result;
MessageHeaders sourceHeaders = source.Headers;
MessageVersion sourceVersion = source.Version;
UnderstoodHeaders understoodHeaders = sourceHeaders.UnderstoodHeaders;
HashSet <string> understoodHeadersSet = CreateKeys(understoodHeaders);
#if DEBUG_MARSHALING
System.Text.StringBuilder details = new System.Text.StringBuilder();
details.AppendFormat("Original Message:\r\n{0}\r\n", source);
details.AppendLine("Understood Headers:");
foreach (MessageHeaderInfo understoodHeader in understoodHeaders)
{
details.AppendFormat("\t{0}\t({1})\r\n", understoodHeader.Name, understoodHeader.Namespace);
}
details.AppendLine("Properties:");
foreach (KeyValuePair <string, object> item in source.Properties)
{
details.AppendFormat("\t{0}\t({1})\r\n", item.Key, item.Value);
}
#endif //DEBUG_MARSHALING
//if we've understood and verified the security of the message, we need to create a new message
if (sourceVersion == targetVersion && !RoutingUtilities.IsMessageUsingWSSecurity(understoodHeaders))
{
FilterHeaders(sourceHeaders, understoodHeadersSet);
FilterProperties(source.Properties);
result = source;
}
else
{
if (source.IsFault)
{
MessageFault messageFault = MessageFault.CreateFault(source, int.MaxValue);
string action = sourceHeaders.Action;
if (string.Equals(action, sourceVersion.Addressing.DefaultFaultAction, StringComparison.Ordinal))
{
//The action was the default for the sourceVersion set it to the default for the targetVersion.
action = targetVersion.Addressing.DefaultFaultAction;
}
result = Message.CreateMessage(targetVersion, messageFault, action);
}
else if (source.IsEmpty)
{
result = Message.CreateMessage(targetVersion, sourceHeaders.Action);
}
else
{
XmlDictionaryReader bodyReader = source.GetReaderAtBodyContents();
result = Message.CreateMessage(targetVersion, sourceHeaders.Action, bodyReader);
}
CloneHeaders(result.Headers, sourceHeaders, to, understoodHeadersSet);
CloneProperties(result.Properties, source.Properties);
}
#if DEBUG_MARSHALING
details.AppendFormat("\r\nMarshaled Message:\r\n{0}\r\n", result);
details.AppendLine("Properties:");
foreach (KeyValuePair <string, object> item in result.Properties)
{
details.AppendFormat("\t{0}\t({1})\r\n", item.Key, item.Value);
}
System.Diagnostics.Trace.WriteLine(details);
TD.RoutingServiceDisplayConfig(details.ToString(), "");
#endif //DEBUG_MARSHALING
return(result);
}
public void DrawCustomInspector()
{
TC_GlobalSettings globalSettings = TC_Settings.instance.global;
serializedObject.Update();
global.Update();
TD.DrawSpacer();
TD.DrawLabelWidthUnderline("Local Settings", 14);
EditorGUILayout.BeginVertical("Box");
GUILayout.Space(5);
TD.DrawProperty(masterTerrain, new GUIContent("Master Terrain", globalSettings.tooltip ? "This terrain is used for selecting the splat textures, grass textures and trees in the nodes." : ""));
EditorGUILayout.BeginHorizontal();
EditorGUILayout.PrefixLabel(new GUIContent("Node Preview Image Resolution", globalSettings.tooltip ? "The resolution of the node preview images." : ""));
previewResolution.intValue = EditorGUILayout.IntPopup(previewResolution.intValue, previewResolutionsDisplay, previewResolutions);
EditorGUILayout.EndHorizontal();
TD.DrawProperty(hideTerrainGroup, new GUIContent("Hide TerrainLayer GameObject"));
if (GUI.changed)
{
serializedObject.ApplyModifiedProperties();
TC_NodeWindow.DebugMode();
}
EditorGUILayout.EndVertical();
GUILayout.Space(10);
TD.DrawSpacer();
GUILayout.Space(10);
TD.DrawLabelWidthUnderline("Global Settings", 14);
GUILayout.Space(5);
EditorGUILayout.BeginVertical("Box");
TD.DrawProperty(tooltip);
GUI.changed = false;
Vector3 defaultTerrainSize = globalSettings.defaultTerrainSize;
defaultTerrainSize = EditorGUILayout.Vector3Field("Default Node Size", defaultTerrainSize);
if (GUI.changed)
{
Undo.RecordObject(globalSettings, "Default Terrain Size");
globalSettings.defaultTerrainSize = defaultTerrainSize;
EditorUtility.SetDirty(globalSettings);
}
EditorGUILayout.EndVertical();
GUILayout.Space(5);
TD.DrawLabelWidthUnderline("Keys", 12);
EditorGUILayout.BeginVertical("Box");
TD.DrawProperty(keyZoomIn);
TD.DrawProperty(keyZoomOut);
EditorGUILayout.EndVertical();
TD.DrawLabelWidthUnderline("Node Colors", 12);
EditorGUILayout.BeginVertical("Box");
TD.DrawProperty(colLayerGroup, new GUIContent("Color Layer Group"));
TD.DrawProperty(colLayer, new GUIContent("Color Layer"));
TD.DrawProperty(colMaskNodeGroup, new GUIContent("Color Mask Node Group"));
TD.DrawProperty(colMaskNode, new GUIContent("Color Mask Node"));
TD.DrawProperty(colSelectNodeGroup, new GUIContent("Color Select Node Group"));
TD.DrawProperty(colSelectNode, new GUIContent("Color Select Node"));
TD.DrawProperty(colSelectItemGroup, new GUIContent("Color Select Item Group"));
TD.DrawProperty(colSelectItem, new GUIContent("Color Select Item"));
EditorGUILayout.EndVertical();
GUILayout.Space(5);
TD.DrawPropertyArray(previewColors);
TD.DrawSpacer();
serializedObject.ApplyModifiedProperties();
global.ApplyModifiedProperties();
}
internal void AfterReply(ref ProxyRpc rpc)
{
if (!_isOneWay)
{
Message reply = rpc.Reply;
if (_deserializeReply)
{
if (TD.ClientFormatterDeserializeReplyStartIsEnabled())
{
TD.ClientFormatterDeserializeReplyStart(rpc.EventTraceActivity);
}
rpc.ReturnValue = _formatter.DeserializeReply(reply, rpc.OutputParameters);
if (TD.ClientFormatterDeserializeReplyStopIsEnabled())
{
TD.ClientFormatterDeserializeReplyStop(rpc.EventTraceActivity);
}
}
else
{
rpc.ReturnValue = reply;
}
int offset = _parent.ParameterInspectorCorrelationOffset;
try
{
for (int i = _parameterInspectors.Length - 1; i >= 0; i--)
{
_parameterInspectors[i].AfterCall(_name,
rpc.OutputParameters,
rpc.ReturnValue,
rpc.Correlation[offset + i]);
if (TD.ClientParameterInspectorAfterCallInvokedIsEnabled())
{
TD.ClientParameterInspectorAfterCallInvoked(rpc.EventTraceActivity, _parameterInspectors[i].GetType().FullName);
}
}
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
if (ErrorBehavior.ShouldRethrowClientSideExceptionAsIs(e))
{
throw;
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperCallback(e);
}
if (_parent.ValidateMustUnderstand)
{
Collection <MessageHeaderInfo> headersNotUnderstood = reply.Headers.GetHeadersNotUnderstood();
if (headersNotUnderstood != null && headersNotUnderstood.Count > 0)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ProtocolException(SR.Format(SR.SFxHeaderNotUnderstood, headersNotUnderstood[0].Name, headersNotUnderstood[0].Namespace)));
}
}
}
}
void DrawCustomInspector()
{
TD.DrawSpacer();
TD.DrawLabel("This script is needed for generating on the GPU", 12);
TD.DrawSpacer();
}
protected override SecurityToken VerifySignature(SignedXml signedXml, bool isPrimarySignature,
SecurityHeaderTokenResolver resolver, object signatureTarget, string id)
{
if (TD.SignatureVerificationStartIsEnabled())
{
TD.SignatureVerificationStart(this.EventTraceActivity);
}
SecurityToken token = ResolveSignatureToken(signedXml.Signature.KeyIdentifier, resolver, isPrimarySignature);
if (isPrimarySignature)
{
RecordSignatureToken(token);
}
ReadOnlyCollection <SecurityKey> keys = token.SecurityKeys;
SecurityKey securityKey = (keys != null && keys.Count > 0) ? keys[0] : null;
if (securityKey == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MessageSecurityException(
SR.GetString(SR.UnableToCreateICryptoFromTokenForSignatureVerification, token)));
}
this.AlgorithmSuite.EnsureAcceptableSignatureKeySize(securityKey, token);
this.AlgorithmSuite.EnsureAcceptableSignatureAlgorithm(securityKey, signedXml.Signature.SignedInfo.SignatureMethod);
signedXml.StartSignatureVerification(securityKey);
StandardSignedInfo signedInfo = (StandardSignedInfo)signedXml.Signature.SignedInfo;
ValidateDigestsOfTargetsInSecurityHeader(signedInfo, this.Timestamp, isPrimarySignature, signatureTarget, id);
if (!isPrimarySignature)
{
if ((!this.RequireMessageProtection) && (securityKey is AsymmetricSecurityKey) && (this.Version.Addressing != AddressingVersion.None))
{
// For Transport Security using Asymmetric Keys verify that
// the 'To' header is signed.
int headerIndex = this.Message.Headers.FindHeader(XD.AddressingDictionary.To.Value, this.Message.Version.Addressing.Namespace);
if (headerIndex == -1)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MessageSecurityException(SR.GetString(SR.TransportSecuredMessageMissingToHeader)));
}
XmlDictionaryReader toHeaderReader = this.Message.Headers.GetReaderAtHeader(headerIndex);
id = toHeaderReader.GetAttribute(XD.UtilityDictionary.IdAttribute, XD.UtilityDictionary.Namespace);
// DevDiv:938534 - We added a flag that allow unsigned headers. If this is set, we do not throw an Exception but move on to CompleteSignatureVerification()
if (LocalAppContextSwitches.AllowUnsignedToHeader)
{
// The lack of an id indicates that the sender did not wish to sign the header. We can safely assume that null indicates this header is not signed.
// If id is not null, then we need to validate the Digest and ensure signature is valid. The exception is thrown deeper in the System.IdentityModel stack.
if (id != null)
{
signedXml.EnsureDigestValidityIfIdMatches(id, toHeaderReader);
}
}
else
{
// default behavior for all platforms
if (id == null)
{
//
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MessageSecurityException(SR.GetString(SR.UnsignedToHeaderInTransportSecuredMessage)));
}
signedXml.EnsureDigestValidity(id, toHeaderReader);
}
}
signedXml.CompleteSignatureVerification();
return(token);
}
this.pendingSignature = signedXml;
if (TD.SignatureVerificationSuccessIsEnabled())
{
TD.SignatureVerificationSuccess(this.EventTraceActivity);
}
return(token);
}
public TC GetContent(TD data)
{
return(getRowElementFunc(data));
}
public object InvokeEnd(object instance, out object[] outputs, IAsyncResult result)
{
object obj2;
if (instance == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("SFxNoServiceObject")));
}
outputs = EmptyArray.Allocate(this.OutputParameterCount);
bool flag = true;
bool flag2 = false;
try
{
ServiceModelActivity activity = null;
Activity boundOperation = null;
this.GetActivityInfo(ref activity, ref boundOperation);
using (boundOperation)
{
obj2 = this.InvokeEndDelegate(instance, outputs, result);
flag = false;
}
ServiceModelActivity.Stop(activity);
}
catch (SecurityException exception)
{
DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Warning);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(AuthorizationBehavior.CreateAccessDeniedFaultException());
}
catch (FaultException)
{
flag2 = true;
flag = false;
throw;
}
finally
{
if (flag)
{
if (TD.OperationFailedIsEnabled())
{
TD.OperationFailed(this.EndMethod.Name, TraceUtility.GetUtcBasedDurationForTrace(TraceUtility.ExtractAsyncOperationStartTime()));
}
}
else if (flag2)
{
if (TD.OperationFaultedIsEnabled())
{
TD.OperationFaulted(this.EndMethod.Name, TraceUtility.GetUtcBasedDurationForTrace(TraceUtility.ExtractAsyncOperationStartTime()));
}
}
else if (TD.OperationCompletedIsEnabled())
{
TD.OperationCompleted(this.EndMethod.Name, TraceUtility.GetUtcBasedDurationForTrace(TraceUtility.ExtractAsyncOperationStartTime()));
}
if (PerformanceCounters.PerformanceCountersEnabled)
{
if (flag)
{
PerformanceCounters.MethodReturnedError(this.endMethod.Name.Substring("End".Length));
}
else if (flag2)
{
PerformanceCounters.MethodReturnedFault(this.endMethod.Name.Substring("End".Length));
}
else
{
PerformanceCounters.MethodReturnedSuccess(this.endMethod.Name.Substring("End".Length));
}
}
}
return(obj2);
}
internal Row(ref TD data, IEnumerable <Column> cells)
{
this.cells = cells;
this.data = data;
}
static public void ClickMenuInput(object obj)
{
int instanceID;
string command = TD.ObjectToCommandAndInstanceID(obj, out instanceID);
TC_Node node = EditorUtility.InstanceIDToObject(instanceID) as TC_Node;
if (node != null)
{
int index = command.IndexOf("/");
string inputKind = command.Substring(0, index);
string input = command.Substring(index + 1);
bool changed = false;
InputKind oldInputKind = node.inputKind;
node.inputKind = (InputKind)Enum.Parse(typeof(InputKind), inputKind);
if (node.inputKind != oldInputKind)
{
changed = true;
}
if (inputKind == "Terrain")
{
InputTerrain oldInputTerrain = node.inputTerrain;
node.inputTerrain = (InputTerrain)Enum.Parse(typeof(InputTerrain), input);
if (node.inputTerrain != oldInputTerrain)
{
changed = true;
}
}
else if (inputKind == "Noise")
{
InputNoise oldInputNoise = node.inputNoise;
node.inputNoise = (InputNoise)Enum.Parse(typeof(InputNoise), input);
if (node.inputNoise != oldInputNoise)
{
changed = true;
}
}
else if (inputKind == "Shape")
{
InputShape oldInputShape = node.inputShape;
node.inputShape = (InputShape)Enum.Parse(typeof(InputShape), input);
if (node.inputShape != oldInputShape)
{
changed = true;
}
}
else if (inputKind == "File")
{
InputFile oldInputFile = node.inputFile;
node.inputFile = (InputFile)Enum.Parse(typeof(InputFile), input);
if (node.inputFile != oldInputFile)
{
changed = true;
}
}
else if (inputKind == "Current")
{
InputCurrent oldInputCurrent = node.inputCurrent;
node.inputCurrent = (InputCurrent)Enum.Parse(typeof(InputCurrent), input);
if (node.inputCurrent != oldInputCurrent)
{
changed = true;
}
}
else if (inputKind == "Portal")
{
InputPortal oldInputPortal = node.inputPortal;
node.inputPortal = (InputPortal)Enum.Parse(typeof(InputPortal), input);
if (node.inputPortal != oldInputPortal)
{
changed = true;
}
}
if (changed)
{
node.Init();
EditorUtility.SetDirty(node);
TC.RefreshOutputReferences(node.outputId, true);
}
}
}
private void sandDockManager1_DockControlClosing(object sender, TD.SandDock.DockControlClosingEventArgs e)
{
// If this is a tabbed document, prompt to save changes
if (e.DockControl is TabbedDocument)
{
DialogResult result = MessageBox.Show(this, "Do you wish to save changes made to " + e.DockControl.Text + "?", "Close Document", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Exclamation);
if (result == DialogResult.Cancel)
e.Cancel = true;
}
}
// This method should only be called when we relinquished the thread but did not
// complete the operation (silent yield is the current example)
public void InternalResume(RequestedAction action)
{
Fx.Assert(_isRunning, "We should still be processing work - we just don't have a thread");
bool isTracingEnabled = CoreWf.Internals.FxTrace.ShouldTraceInformation;
bool notifiedCompletion = false;
bool isInstanceComplete = false;
if (_callbacks.IsAbortPending)
{
_isPausing = false;
_isRunning = false;
this.NotifyWorkCompletion();
notifiedCompletion = true;
if (isTracingEnabled)
{
isInstanceComplete = _callbacks.IsCompleted;
}
// After calling SchedulerIdle we no longer have the lock. That means
// that any subsequent processing in this method won't have the single
// threaded guarantee.
_callbacks.SchedulerIdle();
}
else if (object.ReferenceEquals(action, s_continueAction))
{
ScheduleWork(false);
}
else
{
Fx.Assert(action is NotifyUnhandledExceptionAction, "This is the only other choice because we should never have YieldSilently here");
NotifyUnhandledExceptionAction notifyAction = (NotifyUnhandledExceptionAction)action;
// We only set isRunning back to false so that the host doesn't
// have to treat this like a pause notification. As an example,
// a host could turn around and call run again in response to
// UnhandledException without having to go through its operation
// dispatch loop first (or request pause again). If we reset
// isPausing here then any outstanding operations wouldn't get
// signaled with that type of host.
_isRunning = false;
this.NotifyWorkCompletion();
notifiedCompletion = true;
if (isTracingEnabled)
{
isInstanceComplete = _callbacks.IsCompleted;
}
_callbacks.NotifyUnhandledException(notifyAction.Exception, notifyAction.Source);
}
if (isTracingEnabled)
{
if (notifiedCompletion)
{
Guid oldActivityId = Guid.Empty;
bool resetId = false;
if (isInstanceComplete)
{
if (TD.WorkflowActivityStopIsEnabled())
{
TD.SetActivityId(_callbacks.WorkflowInstanceId, out oldActivityId);
resetId = true;
TD.WorkflowActivityStop(_callbacks.WorkflowInstanceId);
}
}
else
{
if (TD.WorkflowActivitySuspendIsEnabled())
{
TD.SetActivityId(_callbacks.WorkflowInstanceId, out oldActivityId);
resetId = true;
TD.WorkflowActivitySuspend(_callbacks.WorkflowInstanceId);
}
}
if (resetId)
{
TD.CurrentActivityId = oldActivityId;
}
}
}
}
private void sandDockManager1_ShowControlContextMenu(object sender, TD.SandDock.ShowControlContextMenuEventArgs e)
{
ctxWindow.Show(e.DockControl, e.Position);
}
/// <summary>
/// Update main user interface.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Events_Closing(object sender, TD.SandDock.DockControlClosingEventArgs e)
{
this.ApplicationForm.CloseEventViewer();
}
private void sandDockManager1_DockControlRemoved(object sender, TD.SandDock.DockControlEventArgs e)
{
AppendLog("DockControl Removed: " + e.DockControl.Text);
}
private void MenuItem_BeforePopup(object sender, TD.SandBar.MenuPopupEventArgs e) {
try {
// Get Schema and ActiveModel
SchemaModel schemaModel = null;
EsriModel activeModel = null;
DockControl[] dockControls = this.sandDockManager1.GetDockControls(DockSituation.Document);
TabbedDocument activeTab = null;
if (dockControls.Length > 0) {
foreach (TabbedDocument tab2 in dockControls) {
if (tab2 is ITabModel) {
ITabModel tabModel = (ITabModel)tab2;
if (tabModel.Model.GetType() == typeof(SchemaModel)) {
schemaModel = (SchemaModel)tabModel.Model;
break;
}
}
}
activeTab = this.sandDockManager1.ActiveTabbedDocument as TabbedDocument;
if (activeTab is ITabModel) {
ITabModel tabModel = (ITabModel)activeTab;
activeModel = tabModel.Model;
}
}
if (sender == this.menuBarItemFile) {
this.menuButtonItemNew.Enabled = true;
this.menuButtonItemOpen.Enabled = true;
this.menuButtonItemClose.Enabled = (schemaModel != null);
this.menuButtonItemSave.Enabled = (schemaModel != null);
this.menuButtonItemSaveAs.Enabled = (schemaModel != null);
this.menuButtonItemPublish.Enabled = (schemaModel != null);
this.menuButtonItemExport.Enabled = (dockControls.Length != 0);
this.menuButtonItemPrintSetup.Enabled = (activeTab != null && (activeTab is ITabModel || activeTab is ITabPrinter));
this.menuButtonItemPrint.Enabled = (dockControls.Length != 0);
this.menuButtonItemPrintPreview.Enabled = (dockControls.Length != 0);
this.menuButtonItemExit.Enabled = true;
string save = (schemaModel == null) ? string.Empty : schemaModel.Title;
this.menuButtonItemSave.Text = string.Format(Resources.TEXT_SAVE_, save);
this.menuButtonItemSaveAs.Text = string.Format(Resources.TEXT_SAVE_AS_, save);
}
else if (sender == this.menuBarItemEdit) {
bool cut = (activeModel != null) && (activeModel.CanCut);
bool copy = (activeModel != null) && (activeModel.CanCopy);
bool paste = (activeModel != null) && (activeModel.CanPaste);
bool delete = (activeModel != null) && (activeModel.CanDelete);
bool undo = (activeModel != null) && (activeModel.CanUndo);
bool redo = (activeModel != null) && (activeModel.CanRedo);
bool selectAll = (activeModel != null) && (activeModel.CanSelectAll);
this.menuButtonItemCut.Enabled = cut;
this.menuButtonItemCopy.Enabled = copy;
this.menuButtonItemPaste.Enabled = paste;
this.menuButtonItemDelete.Enabled = delete;
this.menuButtonItemSelectAll.Enabled = selectAll;
this.menuButtonItemUndo.Enabled = undo;
this.menuButtonItemRedo.Enabled = redo;
}
else if (sender == this.menuBarItemView) {
this.menuButtonItemColorScheme.Enabled = true;
this.menuButtonItemLayout.Enabled = true;
this.menuButtonItemToolbars.Enabled = true;
this.menuButtonItemZoom.Enabled = true;
this.menuButtonItemExceptions.Enabled = true;
this.menuButtonItemStatusBar.Enabled = true;
this.menuButtonItemOverviewWindow.Enabled = true;
this.menuButtonItemCatalogWindow.Enabled = true;
this.menuButtonItemPaletteWindow.Enabled = true;
this.menuButtonItemPropertiesWindow.Enabled = true;
this.menuButtonItemErrorList.Enabled = true;
this.menuButtonItemOverviewWindow.Checked = (this.dockableWindowOverview.IsOpen || this.dockableWindowOverview.DockSituation == DockSituation.Docked);
this.menuButtonItemCatalogWindow.Checked = (this.dockableWindowCatalog.IsOpen || this.dockableWindowCatalog.DockSituation == DockSituation.Docked);
this.menuButtonItemPaletteWindow.Checked = (this.dockableWindowPalette.IsOpen || this.dockableWindowPalette.DockSituation == DockSituation.Docked);
this.menuButtonItemPropertiesWindow.Checked = (this.dockableWindowProperties.IsOpen || this.dockableWindowProperties.DockSituation == DockSituation.Docked);
this.menuButtonItemErrorList.Checked = (this.dockableWindowErrorList.IsOpen || this.dockableWindowErrorList.DockSituation == DockSituation.Docked);
this.menuButtonItemStatusBar.Checked = this.statusBar1.Visible;
}
else if (sender == this.menuButtonItemColorScheme) {
this.menuButtonItemColorSchemeBlack.Checked = (ColorSchemeSettings.Default.ColorScheme == Office2007ColorScheme.Black);
this.menuButtonItemColorSchemeBlue.Checked = (ColorSchemeSettings.Default.ColorScheme == Office2007ColorScheme.Blue);
this.menuButtonItemColorSchemeSilver.Checked = (ColorSchemeSettings.Default.ColorScheme == Office2007ColorScheme.Silver);
}
else if (sender == this.menuButtonItemLayout) {
bool hasActiveModel = activeModel != null;
bool hasSelectedShapes = hasActiveModel && activeModel.SelectedShapes().Count > 1;
this.menuButtonItemCircular.Enabled = hasActiveModel;
this.menuButtonItemForcedDirect.Enabled = hasActiveModel;
this.menuButtonItemHierachical.Enabled = hasActiveModel;
this.menuButtonItemOrthogonal.Enabled = hasActiveModel;
this.menuButtonItemTree.Enabled = hasActiveModel;
this.menuButtonItemAlignLeft.Enabled = hasSelectedShapes;
this.menuButtonItemAlignCenter.Enabled = hasSelectedShapes;
this.menuButtonItemAlignRight.Enabled = hasSelectedShapes;
this.menuButtonItemAlignTop.Enabled = hasSelectedShapes;
this.menuButtonItemAlignMiddle.Enabled = hasSelectedShapes;
this.menuButtonItemAlignBottom.Enabled = hasSelectedShapes;
}
else if (sender == this.menuButtonItemToolbars) {
this.menuButtonItemStandardToolbar.Enabled = true;
this.menuButtonItemLayoutToolbar.Enabled = true;
this.menuButtonItemInteractiveModeToolbar.Enabled = true;
this.menuButtonItemStandardToolbar.Checked = (this.toolBarStandard.Visible);
this.menuButtonItemLayoutToolbar.Checked = (this.toolBarLayout.Visible);
this.menuButtonItemInteractiveModeToolbar.Checked = (this.toolBarInteractiveMode.Visible);
}
else if (sender == this.menuButtonItemZoom) {
this.menuButtonItemZoom300.Enabled = (activeModel != null);
this.menuButtonItemZoom200.Enabled = (activeModel != null);
this.menuButtonItemZoom100.Enabled = (activeModel != null);
this.menuButtonItemZoom75.Enabled = (activeModel != null);
this.menuButtonItemZoom50.Enabled = (activeModel != null);
this.menuButtonItemZoom25.Enabled = (activeModel != null);
this.menuButtonItemZoomFull.Enabled = (activeModel != null);
this.menuButtonItemZoom300.Checked = (activeModel != null && activeModel.Zoom == 300f);
this.menuButtonItemZoom200.Checked = (activeModel != null && activeModel.Zoom == 200f);
this.menuButtonItemZoom100.Checked = (activeModel != null && activeModel.Zoom == 100f);
this.menuButtonItemZoom75.Checked = (activeModel != null && activeModel.Zoom == 75f);
this.menuButtonItemZoom50.Checked = (activeModel != null && activeModel.Zoom == 50f);
this.menuButtonItemZoom25.Checked = (activeModel != null && activeModel.Zoom == 25f);
this.menuButtonItemZoomFull.Checked = false;
}
else if (sender == this.menuBarItemTools) {
this.menuButtonItemNormalMode.Enabled = (activeModel != null);
this.menuButtonItemLinkMode.Enabled = (activeModel != null);
this.menuButtonItemSchemaReport.Enabled = true;
this.menuButtonItemDataReport.Enabled = true;
this.menuButtonItemValidate.Enabled = (schemaModel != null);
this.menuButtonItemOptions.Enabled = true;
this.menuButtonItemNormalMode.Checked = (activeModel != null && activeModel.Runtime.InteractiveMode == InteractiveMode.Normal);
this.menuButtonItemLinkMode.Checked = (activeModel != null && activeModel.Runtime.InteractiveMode == InteractiveMode.AddLine);
}
else if (sender == this.menuBarItemWindow) {
this.menuButtonItemNewHorizontalTabGroup.Enabled = (dockControls.Length > 1);
this.menuButtonItemNewVerticalTabGroup.Enabled = (dockControls.Length > 1);
this.menuButtonItemRestoreTabGroup.Enabled = (dockControls.Length > 1);
this.menuButtonItemCloseAllDocuments.Enabled = (dockControls.Length > 0);
this.menuButtonItemWindows.Enabled = (dockControls.Length > 0);
}
else if (sender == this.menuBarItemHelp) {
this.menuButtonItemUserGuide.Enabled = true;
this.menuButtonItemSendFeedback.Enabled = true;
this.menuButtonItemEsriHome.Enabled = true;
this.menuButtonItemEsriSupportCenter.Enabled = true;
this.menuButtonItemAbout.Enabled = true;
}
else if (sender == this._zoomMenu) {
foreach (ZoomMenuItem item in this._zoomMenu.Items) {
item.Checked = (activeModel != null && activeModel.Zoom == item.Zoom);
}
}
}
catch (Exception ex) {
ExceptionDialog.HandleException(ex);
}
}
private void sandDockManager1_ResolveDockControl(object sender, TD.SandDock.ResolveDockControlEventArgs e)
{
AppendLog("Resolve DockControl: " + e.Guid.ToString());
}
private void menuFile_BeforePopup(object sender, TD.SandBar.MenuPopupEventArgs e)
{
}
private void sandDockManager1_DockControlActivated(object sender, TD.SandDock.DockControlEventArgs e)
{
AppendLog("Activated: " + e.DockControl.Text);
lastActivatedWindow = e.DockControl;
}
private void toolBarWikiServer_ButtonClick(object sender, TD.SandBar.ToolBarItemEventArgs e)
{
if(e.Item == buttonItemConnect)
{
ConnectToWiki();
}
}
public bool CalculateKeys(T target, Message messageToReadHeaders, out InstanceKey instanceKey,
out ICollection <InstanceKey> additionalKeys)
{
SelectRuntime select;
instanceKey = InstanceKey.InvalidKey;
additionalKeys = null;
// this is a query on the serverside, either Receive or SendReply
// Where
if (!this.ExecuteWhere(target, messageToReadHeaders, this.parent.whereRuntime, out select))
{
return(false);
}
Dictionary <string, string> values = new Dictionary <string, string>();
// Select
if (select.Select.Count > 0)
{
bool allOptional = true;
foreach (KeyValuePair <MessageQuery, string> result in this.ExecuteSelect(target, messageToReadHeaders, select.Select, select.IsContextQuery))
{
if (!(result.Key is OptionalMessageQuery))
{
allOptional = false;
}
if (!string.IsNullOrEmpty(result.Value))
{
values.Add(select.Select[result.Key], result.Value);
}
}
if (values.Count == 0)
{
if (!allOptional)
{
throw FxTrace.Exception.AsError(new ProtocolException(SR2.EmptyCorrelationQueryResults));
}
}
else
{
instanceKey = this.GetInstanceKey(values);
if (TD.TraceCorrelationKeysIsEnabled())
{
TraceCorrelationKeys(instanceKey, values);
}
}
}
// SelectAdditional
foreach (KeyValuePair <string, MessageQueryTable <string> > item in select.SelectAdditional)
{
if (additionalKeys == null)
{
additionalKeys = new List <InstanceKey>();
}
values.Clear();
InstanceKey additionalKey = InstanceKey.InvalidKey;
bool allOptional = true;
foreach (KeyValuePair <MessageQuery, string> result in this.ExecuteSelect(target, messageToReadHeaders, item.Value, select.IsContextQuery))
{
if (!(result.Key is OptionalMessageQuery))
{
allOptional = false;
}
if (!string.IsNullOrEmpty(result.Value))
{
values.Add(item.Value[result.Key], result.Value);
}
}
if (values.Count == 0)
{
if (!allOptional)
{
throw FxTrace.Exception.AsError(new ProtocolException(SR2.EmptyCorrelationQueryResults));
}
}
else
{
additionalKey = new CorrelationKey(values, this.parent.scopeName.ToString(), null)
{
Name = item.Key
};
if (TD.TraceCorrelationKeysIsEnabled())
{
TraceCorrelationKeys(additionalKey, values);
}
}
additionalKeys.Add(additionalKey);
}
return(true);
}
private void ContextMenu_BeforePopup(object sender, TD.SandBar.MenuPopupEventArgs e) {
try {
// Exit if no Context Element
if (this._elementContext == null) { return; }
if (sender == this.contextDomainCodedValue) {
this.menuItemDomainCodedValue_OpenDiagram.Enabled = true;
this.menuItemDomainCodedValue_AddCodedValue.Enabled = true;
this.menuItemDomainCodedValue_Validate.Enabled = true;
}
else if (sender == this.contextDomainCodedValueItem) {
this.menuItemDomainCodedValueItem_Delete.Enabled = true;
}
else if (sender == this.contextDomainRange) {
this.menuItemDomainRange_OpenDiagram.Enabled = true;
this.menuItemDomainRange_Validate.Enabled = true;
}
else if (sender == this.contextFeatureClass) {
FeatureClass featureClass = (FeatureClass)this._elementContext;
this.menuItemFeatureClass_AddField.Enabled = true;
this.menuItemFeatureClass_AddIndex.Enabled = true;
this.menuItemFeatureClass_Validate.Enabled = true;
this.menuItemFeatureClass_ViewMetadata.Enabled = !string.IsNullOrEmpty(featureClass.Metadata);
}
else if (sender == this.contextFeatureDataset) {
FeatureDataset featureDataset = (FeatureDataset)this._elementContext;
this.menuItemFeatureDataset_Validate.Enabled = true;
this.menuItemFeatureDataset_ViewMetadata.Enabled = !string.IsNullOrEmpty(featureDataset.Metadata);
}
else if (sender == this.contextField) {
this.menuItemField_AddToIndexes.Enabled = true;
this.menuItemField_Delete.Enabled = true;
}
else if (sender == this.contextGeometricNetwork) {
GeometricNetwork geometricNetwork = (GeometricNetwork)this._elementContext;
this.menuItemGeometricNetwork_OpenDiagram.Enabled = true;
this.menuItemGeometricNetwork_OpenEdgeEdgeDiagram.Enabled = true;
this.menuItemGeometricNetwork_OpenEdgeJunctionDiagram.Enabled = true;
this.menuItemGeometricNetwork_ViewMetadata.Enabled = !string.IsNullOrEmpty(geometricNetwork.Metadata);
}
else if (sender == this.contextIndex) {
this.menuItemIndex_AddField.Enabled = true;
this.menuItemIndex_Delete.Enabled = true;
}
else if (sender == this.contextIndexField) {
this.menuItemIndexField_Delete.Enabled = true;
}
else if (sender == this.contextNetwork) {
// None
}
else if (sender == this.contextObjectClass) {
ObjectClass objectClass = (ObjectClass)this._elementContext;
this.menuItemObjectClass_AddField.Enabled = true;
this.menuItemObjectClass_AddIndex.Enabled = true;
this.menuItemObjectClass_Validate.Enabled = true;
this.menuItemObjectClass_ViewMetadata.Enabled = !string.IsNullOrEmpty(objectClass.Metadata);
}
else if (sender == this.contextRasterBand) {
RasterBand rasterBand = (RasterBand)this._elementContext;
this.menuItemRasterBand_AddField.Enabled = true;
this.menuItemRasterBand_AddIndex.Enabled = true;
this.menuItemRasterBand_Validate.Enabled = true;
this.menuItemRasterBand_ViewMetadata.Enabled = !string.IsNullOrEmpty(rasterBand.Metadata);
}
else if (sender == this.contextRasterCatalog) {
RasterCatalog rasterCatalog = (RasterCatalog)this._elementContext;
this.menuItemRasterCatalog_AddField.Enabled = true;
this.menuItemRasterCatalog_AddIndex.Enabled = true;
this.menuItemRasterCatalog_Validate.Enabled = true;
this.menuItemRasterCatalog_ViewMetadata.Enabled = !string.IsNullOrEmpty(rasterCatalog.Metadata);
}
else if (sender == this.contextRasterDataset) {
RasterDataset rasterDataset = (RasterDataset)this._elementContext;
this.menuItemRasterDataset_Validate.Enabled = true;
this.menuItemRasterDataset_ViewMetadata.Enabled = !string.IsNullOrEmpty(rasterDataset.Metadata);
}
else if (sender == this.contextRelationship) {
RelationshipClass relationshipClass = (RelationshipClass)this._elementContext;
this.menuItemRelationship_AddField.Enabled = true;
this.menuItemRelationship_AddIndex.Enabled = true;
this.menuItemRelationship_OpenDiagram.Enabled = true;
this.menuItemRelationship_Validate.Enabled = true;
this.menuItemRelationship_ViewMetadata.Enabled = !string.IsNullOrEmpty(relationshipClass.Metadata);
}
else if (sender == this.contextSubtype) {
Subtype subtype = (Subtype)this._elementContext;
this.menuItemSubtype_AddField.Enabled = true;
this.menuItemSubtype_SetAsDefault.Enabled = !subtype.Default;
this.menuItemSubtype_Validate.Enabled = true;
}
else if (sender == this.contextSubtypeField) {
this.menuItemSubtypeField_Delete.Enabled = true;
}
else if (sender == this.contextTerrain) {
Terrain terrain = (Terrain)this._elementContext;
this.menuItemTerrain_OpenDiagram.Enabled = true;
}
else if (sender == this.contextTopology) {
Topology topology = (Topology)this._elementContext;
this.menuItemTopology_OpenDiagram.Enabled = true;
this.menuItemTopology_OpenRuleDiagram.Enabled = true;
this.menuItemTopology_Validate.Enabled = true;
this.menuItemTopology_ViewMetadata.Enabled = !string.IsNullOrEmpty(topology.Metadata);
}
}
catch (Exception ex) {
ExceptionDialog.HandleException(ex);
}
}
// int frame = 0;
void OnGUI()
{
// Debug.Log("OnGUI");
ShowMessages();
if (correctSetup == -1)
{
TC.AddMessage("Close and re-open the TerrainComposer window.");
return;
}
if (correctSetup == -2)
{
TC.AddMessage("Can't load default project.\nThis file is needed -> TerrainComposer2/Defaults/TerrainComposer2.prefab.\n\n Please try to close and re-open the TerrainComposer window.");
return;
}
if (correctSetup != 0)
{
return;
}
if (!TD.Init())
{
return;
}
settings = TC_Settings.instance;
TC_Reporter.BenchmarkStart();
TD.countDrawNode = TD.countDrawNodeCulled = 0;
TD.hoverItem = null;
TD.rectWindow = new Rect(0, 0, window.position.width, window.position.height);
settings.selectionOld = Selection.activeTransform;
if (terrainLayer == null)
{
GetLayerLevel();
}
Keys();
ScrollInterface();
TD.eventCurrent = eventCurrent;
GUI.DrawTexture(new Rect(0, 0, window.position.width, window.position.height), TD.texShelfBackground1);
settings.HasMasterTerrain();
TD.showSelectRect = false;
CaptureWindowEvents();
TD.scrollMax = Vector2.zero;
TC_TerrainLayerGUI.Draw(terrainLayer);
DrawCommand.DrawCommandLists();
TC_ItemBehaviourEditor.CheckKeyLockOnSelection(eventCurrent);
TD.DrawCenter(Color.red, 21, 1);
TD.DrawCenter(Color.red, 11, 3);
DrawMenu();
DropDownMenuMain();
if (settings.showFps)
{
if (!EditorGUIUtility.isProSkin)
{
GUI.color = new Color(1, 1, 1, 0.5f);
GUI.DrawTexture(new Rect(180, 0, 250, 17), Texture2D.whiteTexture);
GUI.color = Color.white;
}
string fps = TC_Reporter.BenchmarkStop("| fps ", false);
EditorGUI.LabelField(new Rect((TC_NodeWindow.window.position.width / 2) - 200, 0, 250, 17), "Node Draw " + TD.countDrawNode + "| Nodes Culled " + TD.countDrawNodeCulled + fps);
}
//if (onFocus && correctSetup == 0 && ++frame == 20)
//{
// frame = 0;
// Repaint();
//}
}
