/// <summary>
/// Handles the Initialized event of the SnomedConcepts object.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="BaseTerminologyEventArgs"/> instance containing the event data.</param>
private static void SnomedConcepts_Initialized(object sender, BaseTerminologyEventArgs e)
{
if (TerminologyManager.Initialized != null)
{
TerminologyManager.Initialized(null, e);
}
}
/// <summary>
/// Parses the additional text box.
/// </summary>
/// <param name="text">The text to parse for qualifiers.</param>
/// <param name="inputFieldResult">The input field result.</param>
/// <param name="conceptDetail">The concept detail.</param>
public static void ParseAdditionalTextBox(string text, InputFieldResult inputFieldResult, ConceptDetail conceptDetail)
{
#if SILVERLIGHT
string normalisedSearchString = text.ToUpper(CultureInfo.InvariantCulture);
#else
string normalisedSearchString = text.ToUpperInvariant();
#endif
ObservableCollection <string> domains = new ObservableCollection <string>();
domains.Add(TerminologyManager.QualifiersDomainString);
SearchState searchState = new SearchState();
searchState.SearchTextOriginal = text;
searchState.ConceptDetail = conceptDetail;
searchState.InputFieldResult = inputFieldResult;
if (conceptDetail.RefinableCharacteristics.Count > 0)
{
TerminologyManager.terminologyProviderClient.IndexTextAsync(normalisedSearchString, domains, null, false, TerminologyManager.LocaleString, searchState);
}
else
{
TerminologyManager.RaiseAdditionalTextBoxCompleted(new ObservableCollection <AdditionalTextBoxResult>(), searchState);
}
}
/// <summary>
/// Handles the saved event of the Single Concept matching control.
/// Adds the encoded term to the encoded list box.
/// </summary>
/// <param name="sender">The single concept matching control.</param>
/// <param name="e">The <see cref="System.Windows.RoutedEventArgs"/> instance containing the event data.</param>
private void SingleConceptMatching_Saved(object sender, System.Windows.RoutedEventArgs e)
{
if (this.connected && this.SingleConceptMatching.InputBoxSelectedItem != null)
{
ObservableCollection <AdditionalTextBoxResult> additionalTextBoxResults = new ObservableCollection <AdditionalTextBoxResult>();
foreach (object o in this.SingleConceptMatching.AdditionalTextBoxSelectedTerms)
{
AdditionalTextBoxResult additionalTextBoxResult = o as AdditionalTextBoxResult;
if (additionalTextBoxResult != null)
{
additionalTextBoxResults.Add(additionalTextBoxResult);
}
}
this.ShowProgressBar();
TerminologyManager.EncodeConcept(this.SingleConceptMatching.InputBoxSelectedItem as InputFieldResult, additionalTextBoxResults);
}
else
{
this.EncodeOutput(CreateUnencodedConcept(this.SingleConceptMatching.InputBoxText));
this.SingleConceptMatching.Clear();
this.SingleConceptMatching.FocusInputBox();
}
this.lastInputBoxResults = null;
this.lastInputBoxSearch = string.Empty;
this.lastAdditionalTextBoxSearch = string.Empty;
this.lastAdditionalTextBoxResults = null;
}
/// <summary>
/// Searches this instance.
/// </summary>
private void Search()
{
if (this.SingleConceptMatching.InputBoxText != this.lastInputBoxSearch)
{
this.lastInputBoxSearch = this.SingleConceptMatching.InputBoxText;
if (this.connected)
{
if (!SingleConceptMatchingPage.ValidateInputText(this.SingleConceptMatching.InputBoxText))
{
this.StatusText.Text = SingleConceptMatchingPage.InputTextValidationFailed;
return;
}
this.StatusText.Text = SingleConceptMatchingPage.SearchInProgressText;
this.ShowProgressBar();
this.SingleConceptMatching.InputBoxItemsSource = null;
FilterItem filterItem = this.SingleConceptMatching.SubsetPickerSelectedItem as FilterItem;
TerminologyManager.SearchInputField(SingleConceptMatchingPage.FixupInputText(this.SingleConceptMatching.InputBoxText), filterItem.SubsetCollection);
}
}
else if (this.lastInputBoxResults != null && this.SingleConceptMatching.InputBoxText == this.lastInputBoxResults.SearchTextOriginal)
{
this.SingleConceptMatching.InputBoxItemsSource = this.lastInputBoxResults.InputFieldResults;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="SingleConceptMatchingPage"/> class.
/// </summary>
public SingleConceptMatchingPage()
{
InitializeComponent();
TerminologyManager.Initialized += new EventHandler <BaseTerminologyEventArgs>(this.TerminologyManagerInitialized);
TerminologyManager.InputBoxSearchCompleted += new EventHandler <InputFieldSearchCompletedEventArgs>(this.TerminologyManagerInputBoxSearchCompleted);
TerminologyManager.AdditionalTextBoxParseCompleted += new EventHandler <AdditionalTextBoxParseCompletedEventArgs>(this.TerminologyManagerAdditionalTextBoxParseCompleted);
TerminologyManager.EncodeConceptCompleted += new EventHandler <EncodeConceptCompletedEventArgs>(this.TerminologyManagerEncodeConceptCompleted);
TerminologyManager.GetConceptDetailsCompleted += new EventHandler <GetConceptDetailsCompletedEventArgs>(this.TerminologyManagerGetConceptDetailsCompleted);
this.StatusText.Text = SingleConceptMatchingPage.InitializingText;
this.ShowProgressBar();
TerminologyManager.Initialize();
this.SearchTypeComboBox.Loaded += new System.Windows.RoutedEventHandler(this.SearchTypeComboBox_Loaded);
this.ScenarioComboBox.Loaded += new System.Windows.RoutedEventHandler(this.ScenarioComboBox_Loaded);
this.encodableInputFieldTimer.Interval = TimeSpan.FromMilliseconds(500);
this.encodableInputFieldTimer.Tick += new System.EventHandler(this.EncodableInputFieldTimer_Tick);
this.additionalTextBoxTimer.Interval = TimeSpan.FromMilliseconds(2000);
this.additionalTextBoxTimer.Tick += new EventHandler(this.AdditionalTextBoxTimerTick);
this.outputs.CollectionChanged += new System.Collections.Specialized.NotifyCollectionChangedEventHandler(this.Outputs_CollectionChanged);
this.OutputListBox.ItemsSource = this.outputs;
this.StatusText.UseLayoutRounding = false;
this.SelectedOutputContentPresenter.Content = new SingleConceptMatchingOutput();
}
/// <summary>
/// Handles when the input field's selection changes.
/// </summary>
/// <param name="sender">The Single Concept Matching control.</param>
/// <param name="e">Event Args.</param>
private void SingleConceptMatching_InputBoxSelectionChanged(object sender, EventArgs e)
{
this.SingleConceptMatching.AdditionalTextBoxMatchingTermItemsSource = null;
if (this.SingleConceptMatching.InputBoxSelectedItem != null)
{
TerminologyManager.GetConceptDetails((this.SingleConceptMatching.InputBoxSelectedItem as InputFieldResult).Concept.SnomedConceptId);
}
}
/// <summary>
/// Handles the search by description completed event for the Terminology Provider Client.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="SearchByDescriptionCompletedEventArgs"/> instance containing the event data.</param>
private static void TerminologyProviderClientSearchByDescriptionCompleted(object sender, SearchByDescriptionCompletedEventArgs e)
{
if (e.Error == null && e.Result != null && e.Result.Terms != null)
{
if (e.UserState != null && e.UserState is SearchState)
{
SearchState searchState = e.UserState as SearchState;
switch (searchState.UserState)
{
case UserState.Normal:
if (TerminologyManager.InputBoxSearchCompleted != null)
{
ObservableCollection <InputFieldResult> results = TerminologyManager.PrepareInputFieldResults(e.Result, false);
TerminologyManager.InputBoxSearchCompleted(null, new InputFieldSearchCompletedEventArgs(searchState.SearchTextOriginal, results, TerminologyManager.MaximumNumberOfTerms, e.Result.ExceedsMaxTotal));
}
break;
case UserState.Negated:
searchState.UserState = UserState.Combine;
searchState.OriginalSearchResults = e.Result;
terminologyProviderClient.SearchByDescriptionAsync(searchState.SearchTextOriginal, searchState.Domains, null, false, true, TerminologyManager.LocaleString, 1, 150, 150, searchState);
break;
case UserState.Combine:
if (TerminologyManager.InputBoxSearchCompleted != null)
{
ObservableCollection <InputFieldResult> results = TerminologyManager.PrepareInputFieldResults(searchState.OriginalSearchResults, true, e.Result, false, TerminologyManager.NegationDisplayString, string.Empty);
TerminologyManager.InputBoxSearchCompleted(null, new InputFieldSearchCompletedEventArgs(searchState.SearchTextOriginal, results, TerminologyManager.MaximumNumberOfTerms, e.Result.ExceedsMaxTotal));
}
break;
default:
break;
}
}
else
{
if (TerminologyManager.InputBoxSearchCompleted != null)
{
ObservableCollection <InputFieldResult> results = TerminologyManager.PrepareInputFieldResults(e.Result, false);
TerminologyManager.InputBoxSearchCompleted(null, new InputFieldSearchCompletedEventArgs(null, results, TerminologyManager.MaximumNumberOfTerms, e.Result.ExceedsMaxTotal));
}
}
}
else
{
if (TerminologyManager.InputBoxSearchCompleted != null)
{
SearchState searchState = e.UserState as SearchState;
TerminologyManager.InputBoxSearchCompleted(null, new InputFieldSearchCompletedEventArgs(searchState.SearchTextOriginal, false));
}
}
}
/// <summary>
/// Prepares the input field results.
/// </summary>
/// <param name="firstResults">The first results.</param>
/// <param name="firstResultsNegated">If set to <c>true</c> [first results negated].</param>
/// <param name="secondResults">The second results.</param>
/// <param name="secondResultsNegated">If set to <c>true</c> [second results negated].</param>
/// <param name="prefix">The prefix.</param>
/// <param name="postfix">The postfix.</param>
/// <returns>A list of prepared input field results.</returns>
private static ObservableCollection <InputFieldResult> PrepareInputFieldResults(SearchResult firstResults, bool firstResultsNegated, SearchResult secondResults, bool secondResultsNegated, string prefix, string postfix)
{
ObservableCollection <InputFieldResult> preparedResults = TerminologyManager.PrepareInputFieldResults(firstResults, prefix, postfix, firstResultsNegated);
foreach (InputFieldResult inputFieldResult in TerminologyManager.PrepareInputFieldResults(secondResults, secondResultsNegated))
{
preparedResults.Add(inputFieldResult);
}
return(preparedResults);
}
/// <summary>
/// Handles the GetConceptDetailsCompleted event from TerminologyManager.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="Microsoft.Cui.SamplePages.TerminologyProvider.GetConceptDetailsCompletedEventArgs"/> instance containing the event data.</param>
private void TerminologyManagerGetConceptDetailsCompleted(object sender, GetConceptDetailsCompletedEventArgs e)
{
this.conceptDetail = e.Result;
if (this.SingleConceptMatching.InputBoxSelectedItem != null && ValidateInputText(this.SingleConceptMatching.AdditionalTextBoxText))
{
this.lastAdditionalTextBoxSearch = this.SingleConceptMatching.AdditionalTextBoxText;
if (this.connected)
{
this.StatusText.Text = SingleConceptMatchingPage.SearchInProgressText;
this.ShowProgressBar();
this.indexerCallCount++;
TerminologyManager.ParseAdditionalTextBox(this.SingleConceptMatching.AdditionalTextBoxText, this.SingleConceptMatching.InputBoxSelectedItem as InputFieldResult, this.conceptDetail);
}
}
}
/// <summary>
/// Encodes an additional concept.
/// </summary>
/// <param name="searchState">State of the search.</param>
private static void EncodeAdditionalConcept(SearchState searchState)
{
AttributeValuePair attributeValuePair = new AttributeValuePair(TerminologyManager.ConceptDetailFromConceptItem(searchState.ConceptDetail.Parents[0]), new EncodedConcept(searchState.ConceptDetail));
if (searchState.AdditionalTextBoxResults[0].IsSide)
{
foreach (ConceptDetail conceptDetail in searchState.AdditionalTextBoxResults[0].FindingSites)
{
AttributeValuePair lateralityAttributeValuePair = new AttributeValuePair(SnomedConcepts.FindingSite, new EncodedConcept(conceptDetail));
lateralityAttributeValuePair.Value.AttributeCollection.Add(new AttributeValuePair(SnomedConcepts.Laterality, new EncodedConcept(searchState.AdditionalTextBoxResults[0].SelectedItem)));
if (searchState.InputFieldResult.IsNegated)
{
if (searchState.EncodedConcept.AttributeCollection.Count > 1)
{
searchState.EncodedConcept.AttributeCollection[1].Value.AttributeCollection.Add(lateralityAttributeValuePair);
}
}
else
{
searchState.EncodedConcept.AttributeCollection.Add(lateralityAttributeValuePair);
}
}
}
else
{
if (searchState.InputFieldResult.IsNegated)
{
searchState.EncodedConcept.AttributeCollection[searchState.EncodedConcept.AttributeCollection.Count - 1].Value.AttributeCollection.Add(attributeValuePair);
}
else
{
searchState.EncodedConcept.AttributeCollection.Add(attributeValuePair);
}
}
searchState.UserState = UserState.EncodingAdditionalConcept;
searchState.AdditionalTextBoxResults.RemoveAt(0);
if (searchState.AdditionalTextBoxResults != null && searchState.AdditionalTextBoxResults.Count > 0)
{
AdditionalTextBoxResult additionalTextBoxResult = searchState.AdditionalTextBoxResults[0];
terminologyProviderClient.GetConceptDetailsAsync(additionalTextBoxResult.SelectedItem.SnomedConceptId, TerminologyManager.LocaleString, searchState);
}
}
public static void GetConceptDetails(string snomedConceptId)
{
TerminologyProviderClient terminologyProviderClient = new TerminologyProviderClient();
terminologyProviderClient.GetConceptDetailsCompleted += delegate(object sender, GetConceptDetailsCompletedEventArgs e)
{
if (e.Error == null && e.Result != null)
{
if (TerminologyManager.GetConceptDetailsCompleted != null)
{
TerminologyManager.GetConceptDetailsCompleted(null, e);
}
}
};
terminologyProviderClient.GetConceptDetailsAsync(snomedConceptId, TerminologyManager.LocaleString);
}
/// <summary>
/// Parses the additional text.
/// </summary>
private void ParseAdditionalText()
{
if (this.connected)
{
this.StatusText.Text = SingleConceptMatchingPage.SearchInProgressText;
this.ShowProgressBar();
this.indexerCallCount++;
this.lastAdditionalTextBoxSearch = this.SingleConceptMatching.AdditionalTextBoxText;
if (this.conceptDetail.SnomedConceptId == (this.SingleConceptMatching.InputBoxSelectedItem as InputFieldResult).Concept.SnomedConceptId)
{
TerminologyManager.ParseAdditionalTextBox(this.SingleConceptMatching.AdditionalTextBoxText, this.SingleConceptMatching.InputBoxSelectedItem as InputFieldResult, this.conceptDetail);
}
else
{
TerminologyManager.GetConceptDetails((this.SingleConceptMatching.InputBoxSelectedItem as InputFieldResult).SnomedDescriptionId);
}
}
}
/// <summary>
/// Searches the input field.
/// </summary>
/// <param name="text">The text to be searched.</param>
/// <param name="domains">The domains the Terminology Provider supports.</param>
/// <returns>true if the call was executed.</returns>
public static bool SearchInputField(string text, ObservableCollection <string> domains)
{
SearchState searchState = new SearchState();
searchState.UserState = UserState.Normal;
searchState.Domains = domains;
string normalisedSearchString = TerminologyManager.NormaliseTerm(text);
if (TerminologyManager.ContainsNegative(normalisedSearchString))
{
searchState.UserState = UserState.Negated;
normalisedSearchString = normalisedSearchString.Replace(TerminologyManager.NegationString, string.Empty);
}
searchState.SearchTextOriginal = text;
terminologyProviderClient.SearchByDescriptionAsync(normalisedSearchString, domains, null, false, true, TerminologyManager.LocaleString, 1, TerminologyManager.MaximumNumberOfTerms, TerminologyManager.MaximumNumberOfTerms + 1, searchState);
return(true);
}
/// <summary>
/// Raises the additional text box completed event and doesn't strip laterality results.
/// </summary>
/// <param name="results">The results.</param>
/// <param name="searchState">User state of search.</param>
private static void RaiseAdditionalTextBoxCompleted(ObservableCollection <AdditionalTextBoxResult> results, SearchState searchState)
{
ObservableCollection <AdditionalTextBoxResult> newResults = new ObservableCollection <AdditionalTextBoxResult>();
foreach (AdditionalTextBoxResult additionalTextBoxResult in results)
{
if (additionalTextBoxResult.IsSide && searchState.LateralityFindingSites.Count > 0)
{
additionalTextBoxResult.FindingSites = searchState.LateralityFindingSites;
additionalTextBoxResult.AlternateItems = SnomedConcepts.FindPostCoordinationConcept(additionalTextBoxResult.SelectedItem.Parents[0].SnomedConceptId).Children;
newResults.Add(additionalTextBoxResult);
}
else if (!additionalTextBoxResult.IsSide)
{
newResults.Add(additionalTextBoxResult);
additionalTextBoxResult.AlternateItems = SnomedConcepts.FindPostCoordinationConcept(additionalTextBoxResult.SelectedItem.Parents[0].SnomedConceptId).Children;
}
}
if (TerminologyManager.AdditionalTextBoxParseCompleted != null)
{
TerminologyManager.AdditionalTextBoxParseCompleted(null, new AdditionalTextBoxParseCompletedEventArgs(searchState.SearchTextOriginal, newResults, searchState.ConceptDetail.SnomedConceptId));
}
}
/// <summary>
/// Prepares the input field results.
/// </summary>
/// <param name="searchResult">The search result.</param>
/// <param name="isNegated">If set to <c>true</c> [is negated].</param>
/// <returns>A list of prepared input field results.</returns>
private static ObservableCollection <InputFieldResult> PrepareInputFieldResults(SearchResult searchResult, bool isNegated)
{
return(TerminologyManager.PrepareInputFieldResults(searchResult, string.Empty, string.Empty, isNegated));
}
/// <summary>
/// Handles the index text completed event for the Terminology Provider Client.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="IndexTextCompletedEventArgs"/> instance containing the event data.</param>
private static void TerminologyProviderClientIndexTextCompleted(object sender, IndexTextCompletedEventArgs e)
{
SearchState searchState = null;
if (e.Error == null && e.Result != null && (searchState = e.UserState as SearchState) != null)
{
bool containsSide = false;
ObservableCollection <AdditionalTextBoxResult> additionalTextBoxResults = new ObservableCollection <AdditionalTextBoxResult>();
foreach (IndexerResult indexerResult in e.Result)
{
AdditionalTextBoxResult additionalTextBoxResult = new AdditionalTextBoxResult();
additionalTextBoxResult.SelectedItem = indexerResult.Concept;
additionalTextBoxResult.StartIndex = indexerResult.StartIndex;
additionalTextBoxResult.Length = indexerResult.EndIndex - indexerResult.StartIndex;
additionalTextBoxResult.IsSide = TerminologyManager.IsConceptSide(indexerResult.Concept);
if (additionalTextBoxResult.IsSide)
{
containsSide = true;
}
else
{
ConceptItem foundConcept = null;
foreach (RefinableCharacteristic refinableCharacteristic in searchState.ConceptDetail.RefinableCharacteristics)
{
foundConcept = refinableCharacteristic.ValueConcepts.SingleOrDefault(p => p.SnomedConceptId == indexerResult.Concept.SnomedConceptId);
if (foundConcept != null)
{
break;
}
}
if (foundConcept == null)
{
continue;
}
}
additionalTextBoxResults.Add(additionalTextBoxResult);
}
if (!containsSide)
{
TerminologyManager.RaiseAdditionalTextBoxCompleted(additionalTextBoxResults, searchState);
}
else
{
TerminologyProviderClient terminologyProviderClient = new TerminologyProviderClient();
terminologyProviderClient.GetConceptDetailsCompleted += delegate(object newSender, GetConceptDetailsCompletedEventArgs newEventArgs)
{
searchState = newEventArgs.UserState as SearchState;
};
if (searchState.InputFieldResult != null)
{
searchState.AdditionalTextBoxResults = additionalTextBoxResults;
RefinableCharacteristic refChar = searchState.ConceptDetail.RefinableCharacteristics.SingleOrDefault(p => p.Name == "Finding site");
if (refChar == null)
{
TerminologyManager.RaiseAdditionalTextBoxCompleted(searchState.AdditionalTextBoxResults, searchState);
}
else
{
searchState.UserState = UserState.SearchingFindingSites;
searchState.RemainingItemsToFind = refChar.ValueConcepts.Count;
searchState.AdditionalTextBoxResults = additionalTextBoxResults;
searchState.RefinableCharacteristic = refChar;
TerminologyManager.terminologyProviderClient.GetConceptDetailsAsync(refChar.ValueConcepts[0].SnomedConceptId, TerminologyManager.LocaleString, searchState);
}
}
}
}
else
{
if (TerminologyManager.AdditionalTextBoxParseCompleted != null)
{
if (searchState != null)
{
TerminologyManager.AdditionalTextBoxParseCompleted(null, new AdditionalTextBoxParseCompletedEventArgs(searchState.SearchTextOriginal, false, searchState.InputFieldResult.Concept.SnomedConceptId));
}
else
{
TerminologyManager.AdditionalTextBoxParseCompleted(null, new AdditionalTextBoxParseCompletedEventArgs(string.Empty, false, string.Empty));
}
}
}
}
/// <summary>
/// Handles the get concept details completed event for the Terminologies Provider Client.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="GetConceptDetailsCompletedEventArgs"/> instance containing the event data.</param>
private static void TerminologyProviderClientGetConceptDetailsCompleted(object sender, GetConceptDetailsCompletedEventArgs e)
{
if (e.Error == null && e.Result != null)
{
if (e.UserState is SearchState)
{
SearchState searchState = e.UserState as SearchState;
switch (searchState.UserState)
{
case UserState.EncodingMainConcept:
TerminologyManager.EncodeMainConcept(e.Result, searchState);
break;
case UserState.EncodingAdditionalConcept:
searchState.ConceptDetail = e.Result;
TerminologyManager.EncodeAdditionalConcept(searchState);
break;
case UserState.SearchingFindingSites:
RefinableCharacteristic lateralityRefChar = e.Result.RefinableCharacteristics.SingleOrDefault(p => p.Name == "Laterality");
searchState.RemainingItemsToFind--;
int index = searchState.RefinableCharacteristic.ValueConcepts.Count - searchState.RemainingItemsToFind;
if (lateralityRefChar == null)
{
if (searchState.RemainingItemsToFind > 0)
{
TerminologyManager.terminologyProviderClient.GetConceptDetailsAsync(searchState.RefinableCharacteristic.ValueConcepts[index].SnomedConceptId, TerminologyManager.LocaleString, searchState);
}
else
{
TerminologyManager.RaiseAdditionalTextBoxCompleted(searchState.AdditionalTextBoxResults, searchState);
}
}
else
{
searchState.LateralityFindingSites.Add(e.Result);
if (searchState.RemainingItemsToFind > 0)
{
TerminologyManager.terminologyProviderClient.GetConceptDetailsAsync(searchState.RefinableCharacteristic.ValueConcepts[index].SnomedConceptId, TerminologyManager.LocaleString, searchState);
}
else
{
TerminologyManager.RaiseAdditionalTextBoxCompleted(searchState.AdditionalTextBoxResults, searchState);
}
}
break;
default:
break;
}
switch (searchState.UserState)
{
case UserState.EncodingMainConcept:
case UserState.EncodingAdditionalConcept:
if (searchState.AdditionalTextBoxResults == null || searchState.AdditionalTextBoxResults.Count == 0)
{
if (TerminologyManager.EncodeConceptCompleted != null)
{
TerminologyManager.EncodeConceptCompleted(null, new EncodeConceptCompletedEventArgs(searchState.EncodedConcept));
}
}
break;
}
}
}
else
{
if (TerminologyManager.EncodeConceptCompleted != null)
{
TerminologyManager.EncodeConceptCompleted(null, new EncodeConceptCompletedEventArgs(false));
}
}
}
