Prompt(string caption, string message, Collection<FieldDescription> descriptions) { // Need to implement EchoOnPrompt HandleThrowOnReadAndPrompt(); if (descriptions == null) { throw PSTraceSource.NewArgumentNullException("descriptions"); } if (descriptions.Count < 1) { throw PSTraceSource.NewArgumentException("descriptions", ConsoleHostUserInterfaceStrings.PromptEmptyDescriptionsErrorTemplate, "descriptions"); } // we lock here so that multiple threads won't interleave the various reads and writes here. lock (_instanceLock) { Dictionary<string, PSObject> results = new Dictionary<string, PSObject>(); Boolean cancelInput = false; if (!String.IsNullOrEmpty(caption)) { // Should be a skin lookup WriteLineToConsole(); WriteToConsole(PromptColor, RawUI.BackgroundColor, WrapToCurrentWindowWidth(caption)); WriteLineToConsole(); } if (!String.IsNullOrEmpty(message)) { WriteLineToConsole(WrapToCurrentWindowWidth(message)); } if (AtLeastOneHelpMessageIsPresent(descriptions)) { WriteLineToConsole(WrapToCurrentWindowWidth(ConsoleHostUserInterfaceStrings.PromptHelp)); } int descIndex = -1; foreach (FieldDescription desc in descriptions) { descIndex++; if (desc == null) { throw PSTraceSource.NewArgumentException("descriptions", ConsoleHostUserInterfaceStrings.NullErrorTemplate, string.Format(CultureInfo.InvariantCulture, "descriptions[{0}]", descIndex)); } PSObject inputPSObject = null; string fieldPrompt = null; fieldPrompt = desc.Name; bool fieldEchoOnPrompt = true; // FieldDescription.ParameterAssemblyFullName never returns null. But this is // defense in depth. if (string.IsNullOrEmpty(desc.ParameterAssemblyFullName)) { string paramName = string.Format(CultureInfo.InvariantCulture, "descriptions[{0}].AssemblyFullName", descIndex); throw PSTraceSource.NewArgumentException(paramName, ConsoleHostUserInterfaceStrings.NullOrEmptyErrorTemplate, paramName); } Type fieldType = InternalHostUserInterface.GetFieldType(desc); if (fieldType == null) { if (InternalHostUserInterface.IsSecuritySensitiveType(desc.ParameterTypeName)) { string errMsg = StringUtil.Format(ConsoleHostUserInterfaceStrings.PromptTypeLoadErrorTemplate, desc.Name, desc.ParameterTypeFullName); PromptingException e = new PromptingException(errMsg, null, "BadTypeName", ErrorCategory.InvalidType); throw e; } fieldType = typeof(string); } if (fieldType.GetInterface(typeof(IList).FullName) != null) { // field is a type implementing IList ArrayList inputList = new ArrayList(); // stores all converted user input before // assigned to an array // if the field is an array, the element type can be found; else, use Object Type elementType = typeof(Object); if (fieldType.IsArray) { elementType = fieldType.GetElementType(); int rank = fieldType.GetArrayRank(); // This check may be redundant because it doesn't seem possible to create // an array of zero dimension. if (rank <= 0) { string msg = StringUtil.Format(ConsoleHostUserInterfaceStrings.RankZeroArrayErrorTemplate, desc.Name); ArgumentException innerException = PSTraceSource.NewArgumentException( string.Format(CultureInfo.InvariantCulture, "descriptions[{0}].AssemblyFullName", descIndex)); PromptingException e = new PromptingException(msg, innerException, "ZeroRankArray", ErrorCategory.InvalidOperation); throw e; } } StringBuilder fieldPromptList = new StringBuilder(fieldPrompt); // fieldPromptList = fieldPrompt + "[i] :" fieldPromptList.Append("["); while (true) { fieldPromptList.Append( string.Format(CultureInfo.InvariantCulture, "{0}]: ", inputList.Count)); Boolean inputListEnd = false; Object convertedObj = null; string inputString = PromptForSingleItem(elementType, fieldPromptList.ToString(), fieldPrompt, caption, message, desc, fieldEchoOnPrompt, true, out inputListEnd, out cancelInput, out convertedObj); if (cancelInput || inputListEnd) { break; } else if (!cancelInput) { inputList.Add(convertedObj); // Remove the indices from the prompt fieldPromptList.Length = fieldPrompt.Length + 1; } } // if cancelInput, should throw OperationCancelException? if (!cancelInput) { object tryConvertResult = null; if (LanguagePrimitives.TryConvertTo(inputList, fieldType, out tryConvertResult)) { inputPSObject = PSObject.AsPSObject(tryConvertResult); } else { inputPSObject = PSObject.AsPSObject(inputList); } } } else { string printFieldPrompt = StringUtil.Format(ConsoleHostUserInterfaceStrings.PromptFieldPromptInputSeparatorTemplate, fieldPrompt); // field is not a list Object convertedObj = null; Boolean dummy = false; PromptForSingleItem(fieldType, printFieldPrompt, fieldPrompt, caption, message, desc, fieldEchoOnPrompt, false, out dummy, out cancelInput, out convertedObj); if (!cancelInput) { inputPSObject = PSObject.AsPSObject(convertedObj); } } if (cancelInput) { s_tracer.WriteLine("Prompt canceled"); WriteLineToConsole(); results.Clear(); break; } results.Add(desc.Name, PSObject.AsPSObject(inputPSObject)); } return results; } }
public Collection<int> PromptForChoice(string caption, string message, Collection<ChoiceDescription> choices, IEnumerable<int> defaultChoices) { ConsoleHostUserInterface.ReadLineResult readLineResult = ConsoleHostUserInterface.ReadLineResult.endedOnEnter; Collection<int> nums; this.HandleThrowOnReadAndPrompt(); if (choices != null) { if (choices.Count != 0) { Dictionary<int, bool> nums1 = new Dictionary<int, bool>(); if (defaultChoices != null) { foreach (int defaultChoice in defaultChoices) { if (defaultChoice < 0 || defaultChoice >= choices.Count) { object[] objArray = new object[3]; objArray[0] = "defaultChoice"; objArray[1] = "choices"; objArray[2] = defaultChoice; throw PSTraceSource.NewArgumentOutOfRangeException("defaultChoice", defaultChoice, "ConsoleHostUserInterfaceStrings", "InvalidDefaultChoiceForMultipleSelection", objArray); } else { if (nums1.ContainsKey(defaultChoice)) { continue; } nums1.Add(defaultChoice, true); } } } Collection<int> nums2 = new Collection<int>(); lock (this.instanceLock) { if (!string.IsNullOrEmpty(caption)) { this.WriteLineToConsole(); this.WriteToConsole(this.PromptColor, this.RawUI.BackgroundColor, this.WrapToCurrentWindowWidth(caption)); this.WriteLineToConsole(); } if (!string.IsNullOrEmpty(message)) { this.WriteLineToConsole(this.WrapToCurrentWindowWidth(message)); } string[,] strArrays = null; HostUIHelperMethods.BuildHotkeysAndPlainLabels(choices, out strArrays); this.WriteChoicePrompt(strArrays, nums1, true); if (nums1.Count > 0) { this.WriteLineToConsole(); } int num = 0; while (true) { string str = StringUtil.Format(ConsoleHostUserInterfaceStrings.ChoiceMessage, num); this.WriteToConsole(this.PromptColor, this.RawUI.BackgroundColor, this.WrapToCurrentWindowWidth(str)); string str1 = this.ReadLine(false, "", out readLineResult, true, true); if (readLineResult == ConsoleHostUserInterface.ReadLineResult.endedOnBreak) { string promptCanceledError = ConsoleHostUserInterfaceStrings.PromptCanceledError; PromptingException promptingException = new PromptingException(promptCanceledError, null, "PromptForChoiceCanceled", ErrorCategory.OperationStopped); throw promptingException; } if (str1.Length == 0) { break; } if (str1.Trim() != "?") { int num1 = HostUIHelperMethods.DetermineChoicePicked(str1.Trim(), choices, strArrays); if (num1 >= 0) { nums2.Add(num1); num++; } } else { this.ShowChoiceHelp(choices, strArrays); } } if (nums2.Count == 0 && nums1.Keys.Count >= 0) { foreach (int key in nums1.Keys) { nums2.Add(key); } } nums = nums2; } return nums; } else { object[] objArray1 = new object[1]; objArray1[0] = "choices"; throw PSTraceSource.NewArgumentException("choices", "ConsoleHostUserInterfaceStrings", "EmptyChoicesErrorTemplate", objArray1); } } else { throw PSTraceSource.NewArgumentNullException("choices"); } }
public override int PromptForChoice(string caption, string message, Collection<ChoiceDescription> choices, int defaultChoice) { ConsoleHostUserInterface.ReadLineResult readLineResult = ConsoleHostUserInterface.ReadLineResult.endedOnEnter; int num; this.HandleThrowOnReadAndPrompt(); if (choices != null) { if (choices.Count != 0) { if (defaultChoice < -1 || defaultChoice >= choices.Count) { object[] objArray = new object[2]; objArray[0] = "defaultChoice"; objArray[1] = "choice"; throw PSTraceSource.NewArgumentOutOfRangeException("defaultChoice", defaultChoice, "ConsoleHostUserInterfaceStrings", "InvalidDefaultChoiceErrorTemplate", objArray); } else { lock (this.instanceLock) { if (!string.IsNullOrEmpty(caption)) { this.WriteLineToConsole(); this.WriteToConsole(this.PromptColor, this.RawUI.BackgroundColor, this.WrapToCurrentWindowWidth(caption)); this.WriteLineToConsole(); } if (!string.IsNullOrEmpty(message)) { this.WriteLineToConsole(this.WrapToCurrentWindowWidth(message)); } int num1 = defaultChoice; string[,] strArrays = null; HostUIHelperMethods.BuildHotkeysAndPlainLabels(choices, out strArrays); Dictionary<int, bool> nums = new Dictionary<int, bool>(); if (defaultChoice >= 0) { nums.Add(defaultChoice, true); } do { Label0: this.WriteChoicePrompt(strArrays, nums, false); string str = this.ReadLine(false, "", out readLineResult, true, true); if (readLineResult != ConsoleHostUserInterface.ReadLineResult.endedOnBreak) { if (str.Length != 0) { if (str.Trim() != "?") { num1 = HostUIHelperMethods.DetermineChoicePicked(str.Trim(), choices, strArrays); } else { this.ShowChoiceHelp(choices, strArrays); goto Label0; } } else { if (defaultChoice >= 0) { num1 = defaultChoice; break; } else { goto Label0; } } } else { string promptCanceledError = ConsoleHostUserInterfaceStrings.PromptCanceledError; PromptingException promptingException = new PromptingException(promptCanceledError, null, "PromptForChoiceCanceled", ErrorCategory.OperationStopped); throw promptingException; } } while (num1 < 0); num = num1; } return num; } } else { object[] objArray1 = new object[1]; objArray1[0] = "choices"; throw PSTraceSource.NewArgumentException("choices", "ConsoleHostUserInterfaceStrings", "EmptyChoicesErrorTemplate", objArray1); } } else { throw PSTraceSource.NewArgumentNullException("choices"); } }
public override Dictionary<string, PSObject> Prompt(string caption, string message, Collection<FieldDescription> descriptions) { Dictionary<string, PSObject> strs; this.HandleThrowOnReadAndPrompt(); if (descriptions != null) { if (descriptions.Count >= 1) { lock (this.instanceLock) { Dictionary<string, PSObject> strs1 = new Dictionary<string, PSObject>(); bool flag = false; if (!string.IsNullOrEmpty(caption)) { this.WriteLineToConsole(); this.WriteToConsole(this.PromptColor, this.RawUI.BackgroundColor, this.WrapToCurrentWindowWidth(caption)); this.WriteLineToConsole(); } if (!string.IsNullOrEmpty(message)) { this.WriteLineToConsole(this.WrapToCurrentWindowWidth(message)); } if (ConsoleHostUserInterface.AtLeastOneHelpMessageIsPresent(descriptions)) { this.WriteLineToConsole(this.WrapToCurrentWindowWidth(ConsoleHostUserInterfaceStrings.PromptHelp)); } int num = -1; foreach (FieldDescription description in descriptions) { num++; if (description != null) { PSObject pSObject = null; string name = description.Name; bool flag1 = true; if (!string.IsNullOrEmpty(description.ParameterAssemblyFullName)) { Type fieldType = InternalHostUserInterface.GetFieldType(description); if (fieldType == null) { if (!InternalHostUserInterface.IsSecuritySensitiveType(description.ParameterTypeName)) { fieldType = typeof(string); } else { string str = StringUtil.Format(ConsoleHostUserInterfaceStrings.PromptTypeLoadErrorTemplate, description.Name, description.ParameterTypeFullName); PromptingException promptingException = new PromptingException(str, null, "BadTypeName", ErrorCategory.InvalidType); throw promptingException; } } if (fieldType.GetInterface(typeof(IList).FullName) == null) { string str1 = StringUtil.Format(ConsoleHostUserInterfaceStrings.PromptFieldPromptInputSeparatorTemplate, name); object obj = null; bool flag2 = false; this.PromptForSingleItem(fieldType, str1, name, caption, message, description, flag1, false, out flag2, out flag, out obj); if (!flag) { pSObject = PSObject.AsPSObject(obj); } } else { ArrayList arrayLists = new ArrayList(); Type elementType = typeof(object); if (fieldType.IsArray) { elementType = fieldType.GetElementType(); int arrayRank = fieldType.GetArrayRank(); if (arrayRank <= 0) { string str2 = StringUtil.Format(ConsoleHostUserInterfaceStrings.RankZeroArrayErrorTemplate, description.Name); object[] objArray = new object[1]; objArray[0] = num; ArgumentException argumentException = PSTraceSource.NewArgumentException(string.Format(CultureInfo.InvariantCulture, "descriptions[{0}].AssemblyFullName", objArray)); PromptingException promptingException1 = new PromptingException(str2, argumentException, "ZeroRankArray", ErrorCategory.InvalidOperation); throw promptingException1; } } StringBuilder stringBuilder = new StringBuilder(name); stringBuilder.Append("["); while (true) { object[] count = new object[1]; count[0] = arrayLists.Count; stringBuilder.Append(string.Format(CultureInfo.InvariantCulture, "{0}]: ", count)); bool flag3 = false; object obj1 = null; this.PromptForSingleItem(elementType, stringBuilder.ToString(), name, caption, message, description, flag1, true, out flag3, out flag, out obj1); if (flag || flag3) { break; } if (!flag) { arrayLists.Add(obj1); stringBuilder.Length = name.Length + 1; } } if (!flag) { object obj2 = null; if (!LanguagePrimitives.TryConvertTo(arrayLists, fieldType, out obj2)) { pSObject = PSObject.AsPSObject(arrayLists); } else { pSObject = PSObject.AsPSObject(obj2); } } } if (!flag) { strs1.Add(description.Name, PSObject.AsPSObject(pSObject)); } else { ConsoleHostUserInterface.tracer.WriteLine("Prompt canceled", new object[0]); this.WriteLineToConsole(); strs1.Clear(); break; } } else { object[] objArray1 = new object[1]; objArray1[0] = num; string str3 = string.Format(CultureInfo.InvariantCulture, "descriptions[{0}].AssemblyFullName", objArray1); object[] objArray2 = new object[1]; objArray2[0] = str3; throw PSTraceSource.NewArgumentException(str3, "ConsoleHostUserInterfaceStrings", "NullOrEmptyErrorTemplate", objArray2); } } else { object[] objArray3 = new object[1]; object[] objArray4 = new object[1]; objArray4[0] = num; objArray3[0] = string.Format(CultureInfo.InvariantCulture, "descriptions[{0}]", objArray4); throw PSTraceSource.NewArgumentException("descriptions", "ConsoleHostUserInterfaceStrings", "NullErrorTemplate", objArray3); } } strs = strs1; } return strs; } else { object[] objArray5 = new object[1]; objArray5[0] = "descriptions"; throw PSTraceSource.NewArgumentException("descriptions", "ConsoleHostUserInterfaceStrings", "PromptEmptyDescriptionsErrorTemplate", objArray5); } } else { throw PSTraceSource.NewArgumentNullException("descriptions"); } }
/// <summary> /// /// See base class /// /// </summary> /// <param name="caption"></param> /// <param name="message"></param> /// <param name="choices"></param> /// <param name="defaultChoice"></param> /// <returns></returns> /// <exception cref="ArgumentNullException"> /// /// If <paramref name="choices"/> is null. /// /// </exception> /// <exception cref="ArgumentException"> /// /// If <paramref name="choices"/>.Count is 0. /// /// </exception> /// <exception cref="ArgumentOutOfRangeException"> /// /// If <paramref name="defaultChoice"/> is greater than /// the length of <paramref name="choices"/>. /// /// </exception> /// <exception cref="PromptingException"> /// /// when prompt is canceled by, for example, Ctrl-c. /// /// </exception> public override int PromptForChoice(string caption, string message, Collection<ChoiceDescription> choices, int defaultChoice) { HandleThrowOnReadAndPrompt(); if (choices == null) { throw PSTraceSource.NewArgumentNullException("choices"); } if (choices.Count == 0) { throw PSTraceSource.NewArgumentException("choices", ConsoleHostUserInterfaceStrings.EmptyChoicesErrorTemplate, "choices"); } if ((defaultChoice < -1) || (defaultChoice >= choices.Count)) { throw PSTraceSource.NewArgumentOutOfRangeException("defaultChoice", defaultChoice, ConsoleHostUserInterfaceStrings.InvalidDefaultChoiceErrorTemplate, "defaultChoice", "choice"); } // we lock here so that multiple threads won't interleave the various reads and writes here. lock (_instanceLock) { if (!string.IsNullOrEmpty(caption)) { // Should be a skin lookup WriteLineToConsole(); WriteToConsole(PromptColor, RawUI.BackgroundColor, WrapToCurrentWindowWidth(caption)); WriteLineToConsole(); } if (!string.IsNullOrEmpty(message)) { WriteLineToConsole(WrapToCurrentWindowWidth(message)); } int result = defaultChoice; string[,] hotkeysAndPlainLabels = null; HostUIHelperMethods.BuildHotkeysAndPlainLabels(choices, out hotkeysAndPlainLabels); Dictionary<int, bool> defaultChoiceKeys = new Dictionary<int, bool>(); // add the default choice key only if it is valid. -1 is used to specify // no default. if (defaultChoice >= 0) { defaultChoiceKeys.Add(defaultChoice, true); } do { WriteChoicePrompt(hotkeysAndPlainLabels, defaultChoiceKeys, false); ReadLineResult rlResult; string response = ReadLine(false, "", out rlResult, true, true); if (rlResult == ReadLineResult.endedOnBreak) { string msg = ConsoleHostUserInterfaceStrings.PromptCanceledError; PromptingException e = new PromptingException( msg, null, "PromptForChoiceCanceled", ErrorCategory.OperationStopped); throw e; } if (response.Length == 0) { // they just hit enter. if (defaultChoice >= 0) { // if there's a default, pick that one. result = defaultChoice; break; } continue; } // decide which choice they made. if (response.Trim() == "?") { // show the help ShowChoiceHelp(choices, hotkeysAndPlainLabels); continue; } result = HostUIHelperMethods.DetermineChoicePicked(response.Trim(), choices, hotkeysAndPlainLabels); if (result >= 0) { break; } // their input matched none of the choices, so prompt again } while (true); return result; } }
/// <summary> /// Presents a dialog allowing the user to choose options from a set of options. /// </summary> /// <param name="caption"> /// Caption to precede or title the prompt. E.g. "Parameters for get-foo (instance 1 of 2)" /// </param> /// <param name="message"> /// A message that describes what the choice is for. /// </param> /// <param name="choices"> /// An Collection of ChoiceDescription objects that describe each choice. /// </param> /// <param name="defaultChoices"> /// The index of the labels in the choices collection element to be presented to the user as /// the default choice(s). /// </param> /// <returns> /// The indices of the choice elements that corresponds to the options selected. /// </returns> /// <seealso cref="System.Management.Automation.Host.PSHostUserInterface.PromptForChoice"/> public Collection<int> PromptForChoice(string caption, string message, Collection<ChoiceDescription> choices, IEnumerable<int> defaultChoices) { HandleThrowOnReadAndPrompt(); if (choices == null) { throw PSTraceSource.NewArgumentNullException("choices"); } if (choices.Count == 0) { throw PSTraceSource.NewArgumentException("choices", ConsoleHostUserInterfaceStrings.EmptyChoicesErrorTemplate, "choices"); } Dictionary<int, bool> defaultChoiceKeys = new Dictionary<int, bool>(); if (null != defaultChoices) { foreach (int defaultChoice in defaultChoices) { if ((defaultChoice < 0) || (defaultChoice >= choices.Count)) { throw PSTraceSource.NewArgumentOutOfRangeException("defaultChoice", defaultChoice, ConsoleHostUserInterfaceStrings.InvalidDefaultChoiceForMultipleSelection, "defaultChoice", "choices", defaultChoice); } if (!defaultChoiceKeys.ContainsKey(defaultChoice)) { defaultChoiceKeys.Add(defaultChoice, true); } } } Collection<int> result = new Collection<int>(); // we lock here so that multiple threads won't interleave the various reads and writes here. lock (_instanceLock) { // write caption on the console, if present. if (!string.IsNullOrEmpty(caption)) { // Should be a skin lookup WriteLineToConsole(); WriteToConsole(PromptColor, RawUI.BackgroundColor, WrapToCurrentWindowWidth(caption)); WriteLineToConsole(); } // write message if (!string.IsNullOrEmpty(message)) { WriteLineToConsole(WrapToCurrentWindowWidth(message)); } string[,] hotkeysAndPlainLabels = null; HostUIHelperMethods.BuildHotkeysAndPlainLabels(choices, out hotkeysAndPlainLabels); WriteChoicePrompt(hotkeysAndPlainLabels, defaultChoiceKeys, true); if (defaultChoiceKeys.Count > 0) { WriteLineToConsole(); } // used to display ChoiceMessage like Choice[0],Choice[1] etc int choicesSelected = 0; do { // write the current prompt string choiceMsg = StringUtil.Format(ConsoleHostUserInterfaceStrings.ChoiceMessage, choicesSelected); WriteToConsole(PromptColor, RawUI.BackgroundColor, WrapToCurrentWindowWidth(choiceMsg)); ReadLineResult rlResult; string response = ReadLine(false, "", out rlResult, true, true); if (rlResult == ReadLineResult.endedOnBreak) { string msg = ConsoleHostUserInterfaceStrings.PromptCanceledError; PromptingException e = new PromptingException( msg, null, "PromptForChoiceCanceled", ErrorCategory.OperationStopped); throw e; } // they just hit enter if (response.Length == 0) { // this may happen when // 1. user wants to go with the defaults // 2. user selected some choices and wanted those // choices to be picked. // user did not pick up any choices..choose the default if ((result.Count == 0) && (defaultChoiceKeys.Keys.Count >= 0)) { // if there's a default, pick that one. foreach (int defaultChoice in defaultChoiceKeys.Keys) { result.Add(defaultChoice); } } // allow for no choice selection. break; } // decide which choice they made. if (response.Trim() == "?") { // show the help ShowChoiceHelp(choices, hotkeysAndPlainLabels); continue; } int choicePicked = HostUIHelperMethods.DetermineChoicePicked(response.Trim(), choices, hotkeysAndPlainLabels); if (choicePicked >= 0) { result.Add(choicePicked); choicesSelected++; } // prompt for multiple choices } while (true); return result; } }