/// <summary> /// Adds an action to the <see cref="EditorMenu"/> command entry. /// </summary> /// <remarks> /// <para>Specifying a value of <c>null</c> or simply omitting to specify an /// action will simply result in the <see cref="EditorMenu"/> command being /// disabled ("greyed out").</para> /// </remarks> /// <param name="action">The action to have the command invoke.</param> /// <returns> /// Fluid style API to further define the new command entry. /// </returns> /// <exception cref="System.ArgumentNullException"> /// If <paramref name="action"/> is <c>null</c>. /// </exception> public EditorMenuCommandBinder Action(Action action) { ExceptionUtility.CheckArgumentNotNull(action, "action"); this.Entry.Action += action; return(this); }
/// <summary> /// Adds a parameterized action to the <see cref="EditorMenu"/> command entry. /// </summary> /// <remarks> /// <para>Specifying a value of <c>null</c> or simply omitting to specify an /// action will simply result in the <see cref="EditorMenu"/> command being /// disabled ("greyed out").</para> /// </remarks> /// <typeparam name="TParam">Type of command parameter.</typeparam> /// <param name="action">The action to have the command invoke.</param> /// <param name="param">Parameter for command.</param> /// <returns> /// Fluid style API to further define the new command entry. /// </returns> /// <exception cref="System.ArgumentNullException"> /// If <paramref name="action"/> is <c>null</c>. /// </exception> public EditorMenuCommandBinder Action <TParam>(Action <TParam> action, TParam param) { ExceptionUtility.CheckArgumentNotNull(action, "action"); this.Entry.Action += () => action(param); return(this); }
/// <summary> /// Adds an arbitary parameter to the <see cref="IEditorMenuEntry"/> that can /// assist <see cref="IEditorMenuPresenter"/> implementations by providing them /// with additional per-entry information. /// </summary> /// <param name="parameter">Custom parameter.</param> /// <returns> /// Fluid style API to further define the new command entry. /// </returns> /// <exception cref="System.ArgumentNullException"> /// If <paramref name="parameter"/> is <c>null</c>. /// </exception> public EditorMenuSeparatorBinder Parameter(IEditorMenuEntryParameter parameter) { ExceptionUtility.CheckArgumentNotNull(parameter, "parameter"); this.Entry.Parameters.Add(parameter); return(this); }
/// <summary> /// Initializes a new instance of the <see cref="EditorMenuSeparatorEntry"/> class. /// </summary> /// <param name="path">Path of the separator.</param> /// <exception cref="System.ArgumentNullException"> /// If <paramref name="path"/> is <c>null</c>. /// </exception> /// <exception cref="System.ArgumentException"> /// If <paramref name="path"/> is an invalid full command path. /// </exception> public EditorMenuSeparatorEntry(string path) { ExceptionUtility.CheckArgumentNotNull(path, "path"); EditorMenuInternalUtility.CheckPathArgument(path, "path"); this.Path = path; }
public RelayCommand(Action <object> pObjExecute, Predicate <object> pBolCanExecute) { ExceptionUtility.CheckArgumentNotNull(pObjExecute, "Execute"); this.mObjExecute = pObjExecute; this.mBolCanExecute = pBolCanExecute; }
/// <summary> /// Initializes a new instance of the <see cref="PackageLanguage"/> class. /// </summary> /// <param name="packageName">Name of the package that the language is for.</param> /// <param name="rootCulture">Culture of the non-translated message text in code.</param> /// <exception cref="System.ArgumentNullException"> /// If <paramref name="packageName"/> or <paramref name="rootCulture"/> are <c>null</c>. /// </exception> /// <exception cref="System.ArgumentException"> /// If <paramref name="packageName"/> is an empty string. /// </exception> protected PackageLanguage(string packageName, CultureInfo rootCulture) { ExceptionUtility.CheckExpectedStringArgument(packageName, "packageName"); ExceptionUtility.CheckArgumentNotNull(rootCulture, "rootCulture"); this.packageName = packageName; this.rootCulture = rootCulture; }
/// <summary> /// Initializes a new instance of the <see cref="ElementAdderMenuPopulator{TContext}"/> class. /// </summary> /// <param name="elementContractType">Contract type of addable elements.</param> /// <param name="elementAdder">Object that is used to add new elements to some /// context object.</param> public ElementAdderMenuPopulator(Type elementContractType, IElementAdder <TContext> elementAdder) { ExceptionUtility.CheckArgumentNotNull(elementContractType, "contractType"); this.ElementContractType = elementContractType; this.ElementAdder = elementAdder; this.TypeFilters = new List <Func <Type, bool> >(); }
/// <summary> /// Sets up the language domain instance. /// </summary> /// <param name="domain">The language domain instance.</param> /// <exception cref="System.ArgumentNullException"> /// If <paramref name="domain"/> is <c>null</c>. /// </exception> /// <exception cref="System.InvalidOperationException"> /// If the runtime language has already been setup. /// </exception> public virtual void Setup(ILanguageDomain domain) { ExceptionUtility.CheckArgumentNotNull(domain, "domain"); if (LocalizedStrings != null) { throw new InvalidOperationException("Runtime language has already been setup."); } LocalizedStrings = domain; }
/// <summary> /// Initializes a new instance of <see cref="SerializedPropertyAdaptor"/>. /// </summary> /// <param name="arrayProperty">Serialized property for entire array.</param> /// <param name="fixedItemHeight">Non-zero height overrides property drawer height calculation.</param> public SerializedPropertyAdaptor(SerializedProperty arrayProperty, float fixedItemHeight) { ExceptionUtility.CheckArgumentNotNull(arrayProperty, "arrayProperty"); if (!arrayProperty.isArray) { throw new InvalidOperationException("Specified serialized propery is not an array."); } this.arrayProperty = arrayProperty; this.FixedItemHeight = fixedItemHeight; }
/// <summary> /// Populates a menu with element adder commands. /// </summary> /// <param name="menu">Editor menu.</param> /// <exception cref="System.ArgumentNullException"> /// If <paramref name="menu"/> is <c>null</c>. /// </exception> public void PopulateWithCommands(EditorMenu menu) { ExceptionUtility.CheckArgumentNotNull(menu, "menu"); menu.AddSeparator(); foreach (var command in ElementAdderMenuCommandMeta.InstantiateAnnotatedCommands <TContext>(this.ElementContractType)) { menu.AddCommand(command.FullPath) .Enabled(this.ElementAdder != null && command.CanExecute(this.ElementAdder)) .Action(command.Execute, this.ElementAdder); } }
/// <inheritdoc/> public void Load(CultureInfo culture) { ExceptionUtility.CheckArgumentNotNull(culture, "culture"); if (culture == this.Culture) { return; } this.strings = this.repository.GetLocalizedStrings(culture); this.Culture = culture; this.OnLoaded(); }
/// <summary> /// Initializes a new instance of the <see cref="LocalizedStringsPathsRepository"/> class. /// </summary> /// <param name="paths">An array of paths where localization files can be found. /// Latter paths have precedence over former paths.</param> /// <param name="fileExtension">File extension; for instance, ".mo".</param> /// <param name="loader">Object for loading localized strings.</param> /// <exception cref="System.ArgumentNullException"> /// If <paramref name="paths"/> or <paramref name="loader"/> are <c>null</c>. /// </exception> public LocalizedStringsPathsRepository(string[] paths, string fileExtension, ILocalizedStringsLoader loader) { ExceptionUtility.CheckArgumentNotNull(paths, "paths"); ExceptionUtility.CheckArgumentNotNull(fileExtension, "fileExtension"); ExceptionUtility.CheckArgumentNotNull(loader, "loader"); string filePattern = string.Format( @"^(?<Locale>[a-z]+([\-\\_][a-z]+)*){0}$", Regex.Escape(fileExtension) ); this.paths = paths.ToArray(); this.fileExtension = fileExtension; this.cultureFileNameRegex = new Regex(filePattern, RegexOptions.IgnoreCase); this.loader = loader; }
/// <summary> /// Gets an array of the <see cref="IElementAdderMenuCommand{TContext}"/> types /// that are associated with the specified <paramref name="elementContractType"/>. /// </summary> private static Type[] GetAnnotatedCommandTypes <TContext>(Type elementContractType) { ExceptionUtility.CheckArgumentNotNull(elementContractType, "contractType"); var contractMap = GetContextElementContractCommandTypesMap <TContext>(); if (!contractMap.ContainsKey(elementContractType)) { contractMap[elementContractType] = ( from commandType in GetAnnotatedCommandTypes <TContext>() let attributes = (ElementAdderMenuCommandAttribute[])Attribute.GetCustomAttributes(commandType, typeof(ElementAdderMenuCommandAttribute)) where attributes.Any(attribute => attribute.ContractType == elementContractType) select commandType ).ToArray(); } return(contractMap[elementContractType].ToArray()); }
/// <summary> /// Populates a menu with concrete element types. /// </summary> /// <param name="menu">Editor menu.</param> /// <exception cref="System.ArgumentNullException"> /// If <paramref name="menu"/> is <c>null</c>. /// </exception> public void PopulateWithConcreteTypes(EditorMenu menu) { ExceptionUtility.CheckArgumentNotNull(menu, "menu"); menu.AddSeparator(); foreach (var concreteType in ApplyTypeFilter(TypeMeta.DiscoverImplementations(this.ElementContractType))) { menu.AddCommand(this.FormatTypeDisplayName(concreteType)) .Enabled(this.ElementAdder != null && this.ElementAdder.CanAddElement(concreteType)) .Action(() => { if (this.ElementAdder.CanAddElement(concreteType)) { this.ElementAdder.AddElement(concreteType); } }); } }
/// <summary> /// Initializes a new instance of the <see cref="LanguageDomain"/> class. /// </summary> /// <param name="repository">Repository for accessing localized strings within /// the language domain.</param> /// <exception cref="System.ArgumentNullException"> /// If <paramref name="repository"/> is <c>null</c>. /// </exception> public LanguageDomain(ILocalizedStringsRepository repository) { ExceptionUtility.CheckArgumentNotNull(repository, "repository"); this.repository = repository; }
/// <summary> /// Initializes a new instance of the <see cref="RuntimeLanguage{TImplementation}"/> class. /// </summary> /// <param name="rootCulture">Culture of the non-translated message text in code.</param> /// <exception cref="System.ArgumentNullException"> /// If <paramref name="rootCulture"/> is <c>null</c>. /// </exception> /// <exception cref="System.ArgumentException"> /// If <paramref name="packageName"/> is an empty string. /// </exception> protected RuntimeLanguage(CultureInfo rootCulture) { ExceptionUtility.CheckArgumentNotNull(rootCulture, "rootCulture"); this.rootCulture = rootCulture; }
/// <summary> /// Initializes a new instance of the <see cref="EditorMenuSeparatorBinder"/> class. /// </summary> /// <param name="entry">The associated separator entry.</param> /// <exception cref="System.ArgumentNullException"> /// If <paramref name="entry"/> is <c>null</c>. /// </exception> public EditorMenuSeparatorBinder(EditorMenuSeparatorEntry entry) { ExceptionUtility.CheckArgumentNotNull(entry, "entry"); this.Entry = entry; }
/// <summary> /// Initializes a new instance of the <see cref="EditorMenuCommandBinder"/> class. /// </summary> /// <param name="entry">The associated command entry.</param> /// <exception cref="System.ArgumentNullException"> /// If <paramref name="entry"/> is <c>null</c>. /// </exception> public EditorMenuCommandBinder(EditorMenuCommandEntry entry) { ExceptionUtility.CheckArgumentNotNull(entry, "entry"); this.Entry = entry; }