/// <summary>
/// Implementors should return any tag/js content
/// to be rendered after the form tag is closed.
/// </summary>
/// <param name="formId">The form id.</param>
/// <returns></returns>
public override string CreateBeforeFormClosed(string formId)
{
var sb = new StringBuilder();
sb.Append("if (!window.prototypeValidators) prototypeValidators = new Object();\n");
sb.AppendFormat("var validator = new Validation('{0}', {1});\n", formId, AjaxHelper.JavascriptOptions(jsOptions));
sb.AppendFormat("prototypeValidators['{0}'] = validator;\n", formId);
if (rules.Count != 0)
{
sb.Append("Validation.addAllThese([\n");
var addedFirstRule = false;
var Comma = "";
foreach (var rule in rules.Values)
{
sb.AppendFormat("{0} ['{1}', '{2}', {{ {3} }}]\n",
Comma, rule.className,
rule.violationMessage != null ? rule.violationMessage.Replace("'", "\'") : null,
rule.rule);
if (!addedFirstRule)
{
addedFirstRule = true;
Comma = ",";
}
}
sb.Append("]);\n");
}
return(AbstractHelper.ScriptBlock(sb.ToString()));
}
public void ScriptBlockGeneratesValidatableXHTML()
{
const string script = "var i = 1;";
var scriptBlock = AbstractHelper.ScriptBlock(script);
Assert.AreEqual("\r\n<script type=\"text/javascript\">/*<![CDATA[*/\r\n" + script + "/*]]>*/</script>\r\n", scriptBlock);
}
private string WrapProxyIfNeeded(string result)
{
if (WrapProxyInScriptBlock)
{
return(AbstractHelper.ScriptBlock(result));
}
return(result);
}
/// <summary>
/// Overwrites a previous message to the output.
/// </summary>
/// <param name="messages">An array of string.</param>
/// <param name="newLine">Whether to add a newline or not.</param>
/// <param name="size">The size of line will overwrites.</param>
/// <param name="stderr">Whether is stderr output.</param>
/// <param name="verbosity">Verbosity level from the verbosity * constants.</param>
private void DoOverwrite(string[] messages, bool newLine = false, int size = -1,
bool stderr = false, Verbosities verbosity = Verbosities.Normal)
{
var message = string.Join(newLine ? Environment.NewLine : string.Empty, messages);
if (size < 0)
{
// since overwrite is supposed to overwrite last message.
size = AbstractHelper.StrlenWithoutDecoration(
Output.Formatter,
(stderr && Output is IOutputConsole) ? lastMessageError : lastMessage);
}
// let's fill its length with backspaces
DoWrite(Str.Repeat("\x08", size), false, stderr, verbosity);
DoWrite(message, false, stderr, verbosity);
// In cmd.exe on Win8.1 (possibly 10?), the line can not
// be cleared, so we need to track the length of previous
// output and fill it with spaces to make sure the line
// is cleared.
var fill = size - AbstractHelper.StrlenWithoutDecoration(Output.Formatter, message);
if (fill > 0)
{
DoWrite(Str.Repeat(fill), false, stderr, verbosity);
DoWrite(Str.Repeat("\x08", fill), false, stderr, verbosity);
}
if (newLine)
{
DoWrite(string.Empty, true, stderr, verbosity);
}
var output = Output;
if (stderr && Output is IOutputConsole consoleOutput)
{
output = consoleOutput.GetErrorOutput();
}
if (!SatisfyVerbosity(output, verbosity))
{
return;
}
if (stderr)
{
lastMessageError = message;
}
else
{
lastMessage = message;
}
}
public void JavascriptAsGenericSortedListTestOptionsTest()
{
IDictionary <string, string> options = new SortedList <string, string>
{
{ "key1", "option1" },
{ "key2", "option2" }
};
Assert.AreEqual("{key1:option1, key2:option2}", AbstractHelper.JavascriptOptions(options));
}
/// <summary>
/// Selects the relevant elements.
/// </summary>
/// <param name="ids">The ids.</param>
private void SelectRelevantElements(params string[] ids)
{
if (ids.Length == 0)
{
throw new InvalidOperationException("Must pass at least one id");
}
CodeGenerator.Write("jQuery(");
CodeGenerator.Write(AbstractHelper.Quote(string.Join(",", ids)));
CodeGenerator.Write(")");
}
public virtual void Report(ProgressChanged value)
{
if (value.IsUnknowSize)
{
io?.OverwriteError($"{prompt}Downloading ({AbstractHelper.FormatMemory(value.ReceivedSize)})", false);
}
else
{
io?.OverwriteError($"{prompt}Downloading (<comment>{value}%</comment>)", false);
}
}
public EditStudentDialog(List<Class> classList, AbstractHelper helper, Action action)
{
InitializeComponent();
this._helper = helper;
this.Text = action + " student";
bEditStud.Text = action.ToString();
foreach (Class c in classList)
{
cmbClassList.Items.Add(c);
cmbEditStudClass.Items.Add(c);
}
cmbClassList.SelectedIndex = -1;
}
/// <summary>
/// Render the validation init script
/// </summary>
/// <param name="formId"></param>
/// <returns></returns>
public override string CreateAfterFormOpened(string formId)
{
var display = CommonUtils.ObtainEntryAndRemove(jsOptions, "display");
var script = new StringBuilder();
script.Append("$('" + formId + "').setAttribute('z:options','" + AjaxHelper.JavascriptOptions(jsOptions) + "')");
script.AppendLine(";");
script.Append("$('" + formId + "').setAttribute('z:display','" + display + "')");
script.AppendLine(";");
return(AbstractHelper.ScriptBlock(script.ToString()));
}
/// <summary>
/// Writes a message to the output.
/// </summary>
/// <param name="messages">An array of string.</param>
/// <param name="newLine">Whether to add a newline or not.</param>
/// <param name="stderr">Whether is stderr output.</param>
/// <param name="verbosity">Verbosity level from the verbosity * constants.</param>
private void DoWrite(string[] messages, bool newLine = false, bool stderr = false,
Verbosities verbosity = Verbosities.Normal)
{
if (!VerbosityMapping.TryGetValue(verbosity, out OutputOptions options))
{
return;
}
if (stopwatch != null && stopwatch.IsRunning)
{
var memoryUsage = AbstractHelper.FormatMemory(Environment.WorkingSet);
var timeSpent = stopwatch.Elapsed;
messages = Arr.Map(messages, (message) =>
{
if (!string.IsNullOrEmpty(message))
{
return($"[{memoryUsage}/{timeSpent.TotalSeconds.ToString("0.00")}s] {message}");
}
return(message);
});
}
if (stderr && Output is IOutputConsole consoleOutput)
{
var errorOutput = consoleOutput.GetErrorOutput();
Array.ForEach(messages, (message) =>
{
errorOutput.Write(message, newLine, options);
});
if (SatisfyVerbosity(errorOutput, options))
{
lastMessageError = string.Join(newLine ? Environment.NewLine : string.Empty, messages);
}
return;
}
Array.ForEach(messages, (message) =>
{
Output.Write(message, newLine, options);
});
if (SatisfyVerbosity(Output, options))
{
lastMessage = string.Join(newLine ? Environment.NewLine : string.Empty, messages);
}
}
public void RedirectTo(object url)
{
string target;
if (url is IDictionary)
{
target = jsCodeGenerator.UrlBuilder.BuildUrl(
jsCodeGenerator.EngineContext.UrlInfo, url as IDictionary);
}
else
{
target = url.ToString();
}
Assign("window.location.href", AbstractHelper.Quote(target));
}
/// <summary>
/// Pendent
/// </summary>
/// <param name="position"></param>
/// <param name="id"></param>
/// <param name="renderOptions"></param>
public override void InsertHtml(string position, string id, object renderOptions)
{
var pos = (Position)Enum.Parse(typeof(Position), position, true);
position = pos.ToString();
var selector = id;
var render = Render(renderOptions);
if (pos == Position.appendTo || pos == Position.prependTo)
{
selector = render.ToString().Replace("\"", "");
render = AbstractHelper.Quote(id);
}
SelectRelevantElements(selector);
CodeGenerator.Write("." + position);
CodeGenerator.Write("(" + render + ");");
WriteNewLine();
}
/// <summary>
/// Outputs the content using the renderOptions approach.
/// <para>
/// If the renderOptions is a string, the content is escaped and quoted.
/// </para>
/// <para>
/// If the renderOptions is a dictionary, we extract the key <c>partial</c>
/// and evaluate the template it points to. The content is escaped and quoted.
/// </para>
/// </summary>
/// <param name="renderOptions">The render options.</param>
/// <returns></returns>
/// <example>
/// The following example uses nvelocity syntax:
/// <code>
/// $page.Call('myJsFunction', $page.render("%{partial='shared/newmessage.vm'}") )
/// </code>
/// <para>
/// Which outputs:
/// </para>
/// <code>
/// myJsFunction('the content from the newmessage partial view template')
/// </code>
/// </example>
public object Render(object renderOptions)
{
if (renderOptions == null)
{
throw new ArgumentNullException("renderOptions",
"renderOptions cannot be null. Must be a string or a dictionary");
}
if (renderOptions is IDictionary)
{
var options = (IDictionary)renderOptions;
var partialName = (String)options["partial"];
if (partialName == null)
{
throw new ArgumentNullException("renderOptions",
"renderOptions, as a dictionary, must have a 'partial' " +
"entry with the template name to render");
}
try
{
var writer = new StringWriter();
viewEngineManager.ProcessPartial(partialName, writer, engineContext, controller, context);
// Ideally we would call (less overhead and safer)
// viewEngineManager.ProcessPartial(partialName, writer, engineContext, parameters);
renderOptions = writer.ToString();
}
catch (Exception ex)
{
throw new MonoRailException("Could not process partial " + partialName, ex);
}
}
return(AbstractHelper.Quote(JsEscape(renderOptions.ToString())));
}
private static void AddParameterToOptions(IDictionary parameters, IDictionary options, string parameterName,
bool quote, string prefixToRemove)
{
var parameterValue = CommonUtils.ObtainEntryAndRemove(parameters, parameterName, null);
var parameterNameToInsert = parameterName;
if (!string.IsNullOrEmpty(prefixToRemove))
{
parameterNameToInsert = parameterName.Replace(prefixToRemove, string.Empty);
}
if (parameterValue != null)
{
if (quote && !parameterValue.StartsWith("'") && !parameterValue.StartsWith("\""))
{
options.Add(parameterNameToInsert, AbstractHelper.SQuote(parameterValue));
}
else
{
options.Add(parameterNameToInsert, parameterValue);
}
}
}
/// <summary>
/// Quotes the specified content.
/// </summary>
/// <param name="content">The content.</param>
/// <returns></returns>
protected string Quote(string content)
{
return(AbstractHelper.Quote(content));
}
/// <summary>
/// Replaces the entire target element -- and not only its innerHTML --
/// by the content evaluated.
/// </summary>
/// <param name="id">The target element id</param>
/// <param name="renderOptions">Defines what to render</param>
/// <example>
/// The following example uses nvelocity syntax:
/// <code>
/// $page.Replace('messagediv', "%{partial='shared/newmessage.vm'}")
/// </code>
/// </example>
public override void Replace(String id, object renderOptions)
{
CodeGenerator.Call("Element.replace", AbstractHelper.Quote(id), Render(renderOptions));
}
/// <summary>
/// Called by the framework so the component can
/// render its content
/// </summary>
public override void Render()
{
Context.Writer.WriteLine(AbstractHelper.ScriptBlock(GenerateJS()));
}
private void SetXmlAsSource()
{
if (xmlUri == null)
{
SelectXml();
}
else
{
lblXmlSelected.Text = LBLSELECTEDXML_SELECTED + xmlUri;
}
helper = new LinqToXmlHelper(xmlUri);
databaseToolStripMenuItem.Checked = false;
xMLToolStripMenuItem.Checked = true;
}
private void SetNetworkAsSource()
{
helper = new NetworkHelper(new Client());
lblXmlSelected.Text = LBLSELECTEDNETWORK;
networkToolStripMenuItem.Checked = true;
}
private void SetDatabaseAsSource()
{
helper = new SqlHelper(StudentsDatabase.GetInstance());
lblXmlSelected.Text = LBLSELECTEDXML_DEFAULT;
databaseToolStripMenuItem.Checked = true;
xMLToolStripMenuItem.Checked = false;
}
/// <summary>
/// Implementors should return any tag/js content
/// to be rendered after the form tag is closed.
/// </summary>
/// <param name="formId">The form id.</param>
/// <returns></returns>
public override string CreateBeforeFormClosed(string formId)
{
var stringBuilder = new StringBuilder();
if (_rules.Count > 0)
{
_options[JQueryOptions.Rules] = AbstractHelper.JavascriptOptions(_rules);
}
if (_messages.Count > 0)
{
_options[JQueryOptions.Messages] = AbstractHelper.JavascriptOptions(_messages);
}
bool isAjax;
bool.TryParse(CommonUtils.ObtainEntryAndRemove(
_options,
JQueryOptions.IsAjax,
bool.FalseString), out isAjax);
if (isAjax)
{
var submitHandler = CommonUtils.ObtainEntryAndRemove(_options, JQueryOptions.SubmitHandler);
if (submitHandler == null)
{
if (_ajaxOptions.Count > 0)
{
_options.Add(
JQueryOptions.SubmitHandler,
string.Concat(
"function( form ) { jQuery( form ).ajaxSubmit( ",
AbstractHelper.JavascriptOptions(_ajaxOptions),
"); }"));
}
else
{
_options.Add(
JQueryOptions.SubmitHandler,
"function( form ) { jQuery( form ).ajaxSubmit(); }");
}
}
}
MergeGroupDefinitionsWithOptions();
GenerateGroupNotEmptyValidatorCustomRule();
GenerateGroupNotEmptyValidatorCustomClass();
stringBuilder.Append("jQuery( document ).ready( function() { ");
stringBuilder.AppendFormat("jQuery(\"#{0}\").validate( {1} );", formId, AbstractHelper.JavascriptOptions(_options));
if (_customRules.Count > 0)
{
foreach (var rule in _customRules.Values)
{
stringBuilder.Append(Environment.NewLine);
stringBuilder.Append("jQuery.validator.addMethod('");
stringBuilder.Append(rule.Name);
stringBuilder.Append("', ");
stringBuilder.Append(rule.Rule);
stringBuilder.Append(", '");
stringBuilder.Append(rule.ViolationMessage);
stringBuilder.Append("' );");
}
}
if (_customClasses.Count > 0)
{
foreach (var pair in _customClasses)
{
stringBuilder.Append(Environment.NewLine);
stringBuilder.Append("jQuery.validator.addClassRules({");
stringBuilder.Append(string.Format("required{0}", pair.Key));
stringBuilder.Append(": ");
stringBuilder.Append(AbstractHelper.JavascriptOptions(pair.Value));
stringBuilder.Append("});");
}
}
stringBuilder.Append(" });");
return(AbstractHelper.ScriptBlock(stringBuilder.ToString()));
}
/// <summary>
/// Inserts a content snippet relative to the element specified by the <paramref name="id"/>
/// <para>
/// The supported positions are
/// Top, After, Before, Bottom
/// </para>
/// </summary>
/// <param name="position">The position to insert the content relative to the element id</param>
/// <param name="id">The target element id</param>
/// <param name="renderOptions">Defines what to render</param>
/// <example>
/// The following example uses nvelocity syntax:
/// <code>
/// $page.InsertHtml('Bottom', 'messagestable', "%{partial='shared/newmessage.vm'}")
/// </code>
/// </example>
public override void InsertHtml(string position, string id, object renderOptions)
{
position = Enum.Parse(typeof(Position), position, true).ToString();
CodeGenerator.Call("new Insertion." + position, AbstractHelper.Quote(id), Render(renderOptions));
}
/// <inheritdoc />
public bool GC(int ttl, int maxSize)
{
if (!Enable)
{
return(false);
}
cacheCollected = true;
var candidates = new SortSet <IMetaData, DateTime>();
var directories = new Queue <string>();
void AddCandidate(string file)
{
var meta = fileSystem.GetMetaData(file);
candidates.Add(meta, meta.LastAccessTime);
}
if (!fileSystem.Exists(CacheDirectory, FileSystemOptions.Directory))
{
return(true);
}
var contents = fileSystem.GetContents(CacheDirectory);
Array.ForEach(contents.GetDirectories(), directories.Enqueue);
Array.ForEach(contents.GetFiles(), AddCandidate);
while (directories.Count > 0)
{
#pragma warning disable S4158 // bug: Empty collections should not be accessed or iterated
contents = fileSystem.GetContents(directories.Dequeue());
#pragma warning restore S4158
Array.ForEach(contents.GetDirectories(), directories.Enqueue);
Array.ForEach(contents.GetFiles(), AddCandidate);
}
var freeSpace = 0L;
var deletedFiles = 0;
// gc with ttl.
var expire = DateTime.Now.AddSeconds(-ttl);
foreach (var candidate in candidates)
{
if (candidate.LastAccessTime >= expire)
{
// The sorset will have sorted the modification time.
break;
}
fileSystem.Delete(candidate.Path);
candidates.Remove(candidate);
freeSpace += candidate.Size;
deletedFiles++;
}
void PromptFree()
{
io.WriteError($"Cache garbage collection completed, delete {deletedFiles} files, free {AbstractHelper.FormatMemory(freeSpace)} space.");
}
// gc with maxSize
var totalSize = fileSystem.GetMetaData(CacheDirectory).Size;
if (totalSize < maxSize)
{
PromptFree();
return(true);
}
foreach (var candidate in candidates)
{
if (totalSize < maxSize)
{
break;
}
fileSystem.Delete(candidate.Path);
totalSize -= candidate.Size;
freeSpace += candidate.Size;
deletedFiles++;
}
PromptFree();
return(true);
}
public static string BuildQueryString(this AbstractHelper helper, System.Object parameters)
{
return(helper.BuildQueryString(new ModelDictionary(parameters)));
}
/// <inheritdoc />
protected override int DoRun(IInput input, IOutput output)
{
disablePluginsByDefault = input.HasRawOption("--no-plugins");
var ioConsole = new IOConsole(input, output);
io = ioConsole;
var commandName = GetCommandName(input);
TryGetCommand(commandName, out BaseCommand command);
LoadPluginCommands(command);
var isProxyCommand = false;
if (!string.IsNullOrEmpty(commandName) || command != null)
{
// Maybe the command is provided by the plugin. If we can't find
// us again, we will stop intercepting the exception.
if (command == null)
{
command = Find(commandName);
}
isProxyCommand = command is Command.BaseCommand baseCommand && baseCommand.IsProxyCommand;
}
if (!isProxyCommand)
{
io.WriteError(
$"Running {Bucket.GetVersionPretty()} ({Bucket.GetVersion()},{Bucket.GetReleaseDataPretty()}) on {Platform.GetOSInfo()}",
verbosity: Verbosities.Debug);
if (!(command is CommandSelfUpdate) && Bucket.IsDev && (DateTime.Now - Bucket.GetReleaseData()) > new TimeSpan(60, 0, 0, 0, 0))
{
io.WriteError(
"<warning>Warning: This development build of bucket is over 60 days old. It is recommended to update it by running \"self-update\" to get the latest version.</warning>");
}
}
Stopwatch stopWatch = null;
try
{
if (input.HasRawOption("--profile"))
{
stopWatch = new Stopwatch();
ioConsole.SetDebugging(stopWatch);
}
stopWatch?.Start();
var exitCode = base.DoRun(input, output);
stopWatch?.Stop();
if (stopWatch != null)
{
var memoryUsage = AbstractHelper.FormatMemory(Environment.WorkingSet);
var timeSpent = stopWatch.Elapsed;
io.WriteError(string.Empty);
io.WriteError($"<info>Memory usage: {memoryUsage}, total time: {timeSpent.TotalSeconds.ToString("0.00")}s</info>");
io.WriteError(string.Empty);
}
return(exitCode);
}
catch (ScriptExecutionException ex)
{
return(ex.ExitCode);
}
}
public void SaveOrUpdate(PageDto item)
{
if (item == null)
{
throw new ArgumentNullException("item", "The post must be contains a valid instance");
}
Page page = this.Session.Load <Page>(item.Id)
?? new Page
{
CreatedAt = DateTimeOffset.Now
};
if (string.IsNullOrEmpty(item.Author))
{
item.Author = Thread.CurrentPrincipal.Identity.Name;
}
item.MapPropertiesToInstance(page);
if (string.IsNullOrEmpty(page.Excerpt))
{
page.Excerpt = AbstractHelper.GenerateAbstract(page.Content);
}
if (string.IsNullOrEmpty(page.Slug))
{
page.Slug = SlugHelper.GenerateSlug(page.Title, page.Id, this.GetPostBySlugInternal);
}
if (page.IsTransient)
{
ItemComments comments = new ItemComments
{
Item = new ItemReference
{
Id = page.Id,
Status = page.Status,
ItemPublishedAt = page.PublishAt
}
};
this.Session.Store(comments);
page.CommentsId = comments.Id;
ItemTrackbacks trackbacks = new ItemTrackbacks
{
Item = new ItemReference
{
Id = page.Id,
Status = page.Status,
ItemPublishedAt = page.PublishAt
}
};
this.Session.Store(trackbacks);
page.TrackbacksId = trackbacks.Id;
}
this.Session.Store(page);
UpdateDenormalizedItemIndex.UpdateIndexes(this.store, this.Session, page);
item.Id = RavenIdHelper.Resolve(page.Id);
}
/// <summary>
/// Quotes the specified content array.
/// </summary>
/// <param name="content">The content array.</param>
/// <returns></returns>
protected string[] Quote(object[] content)
{
return(AbstractHelper.Quote(content));
}
/// <summary>
/// Shows the specified elements.
/// </summary>
/// <param name="ids">The elements ids.</param>
/// <remarks>
/// The elements must exist.
/// </remarks>
/// <example>
/// The following example uses nvelocity syntax:
/// <code>
/// $page.Show('div1', 'div2')
/// </code>
/// </example>
public override void Show(params string[] ids)
{
CodeGenerator.Call("Element.show", AbstractHelper.Quote(ids));
}
/// <summary>
/// Creates the standard helpers.
/// </summary>
public virtual void CreateStandardHelpers()
{
AbstractHelper[] builtInHelpers =
new AbstractHelper[]
{
new AjaxHelper(engineContext), new BehaviourHelper(engineContext),
new UrlHelper(engineContext), new TextHelper(engineContext),
new EffectsFatHelper(engineContext), new ScriptaculousHelper(engineContext),
new DateFormatHelper(engineContext), new HtmlHelper(engineContext),
new ValidationHelper(engineContext), new DictHelper(engineContext),
new PaginationHelper(engineContext), new FormHelper(engineContext),
new JSONHelper(engineContext), new ZebdaHelper(engineContext)
};
foreach(AbstractHelper helper in builtInHelpers)
{
context.Helpers.Add(helper);
if (helper is IServiceEnabledComponent)
{
serviceInitializer.Initialize(helper, engineContext);
}
}
}
public void Alert(object message)
{
Call("alert", AbstractHelper.Quote(message));
}
/// <summary>
/// Selects a method from the given set of methods, based on the argument type.
/// </summary>
/// <returns>
/// A <see cref="T:System.Reflection.MethodBase" /> object containing the matching method, if found; otherwise, null.
/// </returns>
/// <param name="bindingAttr">A bitwise combination of <see cref="T:System.Reflection.BindingFlags" /> values. </param>
/// <param name="match">The set of methods that are candidates for matching. For example, when a <see cref="T:System.Reflection.Binder" /> object is used by <see cref="Overload:System.Type.InvokeMember" />, this is the set of methods Reflection has determined to be possible matches, typically because they have the correct member name. The default implementation provided by <see cref="P:System.Type.DefaultBinder" /> changes the order of this array.</param>
/// <param name="types">The parameter types used to locate a matching method. </param>
/// <param name="modifiers">An array of parameter modifiers that enable binding to work with parameter signatures in which the types have been modified. </param>
/// <exception cref="T:System.Reflection.AmbiguousMatchException">For the default binder, <paramref name="match" /> contains multiple methods that are equally good matches for the parameter types described by <paramref name="types" />. For example, the array in <paramref name="types" /> contains a <see cref="T:System.Type" /> object for MyClass and the array in <paramref name="match" /> contains a method that takes a base class of MyClass and a method that takes an interface that MyClass implements. </exception>
/// <exception cref="T:System.ArgumentException">For the default binder, <paramref name="match" /> is null or an empty array.-or-An element of <paramref name="types" /> derives from <see cref="T:System.Type" />, but is not of type RuntimeType.</exception>
public override MethodBase SelectMethod(BindingFlags bindingAttr, MethodBase[] match, Type[] types, ParameterModifier[] modifiers)
{
bool matchFound;
int currentMatch, bestMatch = -1;
for (int i = 0; i < match.Length; i++)
{
ParameterInfo[] pars = match[i].GetParameters();
if (pars.Length == types.Length)
{
matchFound = true;
currentMatch = 0;
int j = 0;
while (j < pars.Length && matchFound)
{
Type t = types[j];
matchFound = (!pars[j].ParameterType.IsValueType && types[j] == NullType.Default) ||
((bindingAttr & BindingFlags.ExactBinding) == 0 ? (AbstractHelper.IsAssignableFrom(pars[j].ParameterType, t) && (!t.IsValueType || pars[j].ParameterType.IsValueType)) : pars[j].ParameterType == types[j]);
if (matchFound && pars[j].ParameterType.FullName.Equals(types[j].FullName))
{
currentMatch++;
}
j++;
}
if (matchFound && currentMatch > bestMatch)
{
bestMatch = currentMatch;
MethodBase temp = match[0];
match[0] = match[i];
match[i] = temp;
}
}
}
return(bestMatch != -1 ? match[0] : null);
}
/// <summary>
/// Toggles the display status of the specified elements.
/// </summary>
/// <param name="ids">The elements ids.</param>
/// <remarks>
/// The elements must exist.
/// </remarks>
/// <example>
/// The following example uses nvelocity syntax:
/// <code>
/// $page.Toggle('div1', 'div2')
/// </code>
/// </example>
public override void Toggle(params string[] ids)
{
CodeGenerator.Call("Element.toggle", AbstractHelper.Quote(ids));
}
