public void BaseValidator_Validated(object sender, EventArgs e) { BaseValidator validator = (BaseValidator)sender; // If validator is valid, remove from list if (validator.IsValid) { this.validationErrorsList.Items.Remove(validator); } // Add validator to list, in tab index order else { if (!this.validationErrorsList.Items.Contains(validator)) { decimal tabIndex = validator.FlattenedTabIndex; for (int i = 0; i < this.validationErrorsList.Items.Count; i++) { BaseValidator currentValidator = (BaseValidator)this.validationErrorsList.Items[i]; if (tabIndex < currentValidator.FlattenedTabIndex) { this.validationErrorsList.Items.Insert(i, validator); return; } } this.validationErrorsList.Items.Add(validator); } } }
public void Validate() { // Validate BaseValidator firstInTabOrder = null; foreach (BaseValidator validator in GetValidators()) { // Validate control validator.Validate(); // Set focus on the control it its invalid and the earliest invalid // control in the tab order if (!validator.IsValid) { if ((firstInTabOrder == null) || (firstInTabOrder.FlattenedTabIndex > validator.FlattenedTabIndex)) { firstInTabOrder = validator; } } } OnSummarize(new SummarizeEventArgs(GetValidators(), HostingForm)); // Select first invalid control in tab order, if any if (firstInTabOrder != null) { firstInTabOrder.ControlToValidate.Focus(); } }
private void validationErrorsList_DoubleClick(object sender, System.EventArgs e) { // Set focus on the selected BaseValidator's ControlToValidate ie // in the owner form BaseValidator selected = (BaseValidator)this.validationErrorsList.SelectedItem; selected.ControlToValidate.Focus(); }
/// <summary> /// Returns the zero-based index of the first occurrence of a <see cref="BaseValidator"/> /// in the <c>ValidatorCollection</c>. /// </summary> /// <param name="item">The <see cref="BaseValidator"/> to locate in the <c>ValidatorCollection</c>.</param> /// <returns> /// The zero-based index of the first occurrence of <paramref name="item"/> /// in the entire <c>ValidatorCollection</c>, if found; otherwise, -1. /// </returns> public virtual int IndexOf(BaseValidator item) { for (int i = 0; i != m_count; ++i) { if (m_array[i].Equals(item)) { return(i); } } return(-1); }
/// <summary> /// Determines whether a given <see cref="BaseValidator"/> is in the <c>ValidatorCollection</c>. /// </summary> /// <param name="item">The <see cref="BaseValidator"/> to check for.</param> /// <returns><c>true</c> if <paramref name="item"/> is found in the <c>ValidatorCollection</c>; otherwise, <c>false</c>.</returns> public virtual bool Contains(BaseValidator item) { for (int i = 0; i != m_count; ++i) { if (m_array[i].Equals(item)) { return(true); } } return(false); }
public static void DeRegister(BaseValidator validator, Form hostingForm) { // Remove this validator from the list of registered validators ValidatorCollection validators = (ValidatorCollection)_validators[hostingForm]; if (validators != null) { validators.Remove(validator); // Remove form bucket if all validators on the form are de-registered if (validators.Count == 0) _validators.Remove(hostingForm); } }
/// <summary> /// Adds a <see cref="BaseValidator"/> to the end of the <c>ValidatorCollection</c>. /// </summary> /// <param name="item">The <see cref="BaseValidator"/> to be added to the end of the <c>ValidatorCollection</c>.</param> /// <returns>The index at which the value has been added.</returns> public virtual int Add(BaseValidator item) { if (m_count == m_array.Length) { EnsureCapacity(m_count + 1); } m_array[m_count] = item; m_version++; return(m_count++); }
/// <summary> /// Removes the first occurrence of a specific <see cref="BaseValidator"/> from the <c>ValidatorCollection</c>. /// </summary> /// <param name="item">The <see cref="BaseValidator"/> to remove from the <c>ValidatorCollection</c>.</param> /// <exception cref="ArgumentException"> /// The specified <see cref="BaseValidator"/> was not found in the <c>ValidatorCollection</c>. /// </exception> public virtual void Remove(BaseValidator item) { int i = IndexOf(item); if (i < 0) { throw new System.ArgumentException("Cannot remove the specified item because it was not found in the specified Collection."); } ++m_version; RemoveAt(i); }
public static void Register(BaseValidator validator, Form hostingForm) { // Create form bucket if it doesn't exist if (_validators[hostingForm] == null) { _validators[hostingForm] = new ValidatorCollection(); } // Add this validator to the list of registered validators ValidatorCollection validators = (ValidatorCollection)_validators[hostingForm]; validators.Add(validator); }
public static void Register(BaseValidator validator, Form hostingForm) { // Create form bucket if it doesn't exist if (_validators[hostingForm] == null) { _validators[hostingForm] = new ValidatorCollection(); } // Add this validator to the list of registered validators ValidatorCollection validators = (ValidatorCollection)_validators[hostingForm]; validators.Add(validator); }
public int Compare(object x, object y) { BaseValidator xBaseValidator = (BaseValidator)x; BaseValidator yBaseValidator = (BaseValidator)y; if (xBaseValidator.FlattenedTabIndex < yBaseValidator.FlattenedTabIndex) { return(-1); } if (xBaseValidator.FlattenedTabIndex > yBaseValidator.FlattenedTabIndex) { return(1); } return(0); }
public static void DeRegister(BaseValidator validator, Form hostingForm) { // Remove this validator from the list of registered validators ValidatorCollection validators = (ValidatorCollection)_validators[hostingForm]; if (validators != null) { validators.Remove(validator); // Remove form bucket if all validators on the form are de-registered if (validators.Count == 0) { _validators.Remove(hostingForm); } } }
/// <summary> /// Removes the element at the specified index of the <c>ValidatorCollection</c>. /// </summary> /// <param name="index">The zero-based index of the element to remove.</param> /// <exception cref="ArgumentOutOfRangeException"> /// <para><paramref name="index"/> is less than zero</para> /// <para>-or-</para> /// <para><paramref name="index"/> is equal to or greater than <see cref="ValidatorCollection.Count"/>.</para> /// </exception> public virtual void RemoveAt(int index) { ValidateIndex(index); // throws m_count--; if (index < m_count) { Array.Copy(m_array, index + 1, m_array, index, m_count - index); } // We can't set the deleted entry equal to null, because it might be a value type. // Instead, we'll create an empty single-element array of the right type and copy it // over the entry we want to erase. BaseValidator[] temp = new BaseValidator[1]; Array.Copy(temp, 0, m_array, m_count, 1); m_version++; }
/// <summary> /// Inserts an element into the <c>ValidatorCollection</c> at the specified index. /// </summary> /// <param name="index">The zero-based index at which <paramref name="item"/> should be inserted.</param> /// <param name="item">The <see cref="BaseValidator"/> to insert.</param> /// <exception cref="ArgumentOutOfRangeException"> /// <para><paramref name="index"/> is less than zero</para> /// <para>-or-</para> /// <para><paramref name="index"/> is equal to or greater than <see cref="ValidatorCollection.Count"/>.</para> /// </exception> public virtual void Insert(int index, BaseValidator item) { ValidateIndex(index, true); // throws if (m_count == m_array.Length) { EnsureCapacity(m_count + 1); } if (index < m_count) { Array.Copy(m_array, index, m_array, index + 1, m_count - index); } m_array[index] = item; m_count++; m_version++; }
public override void Remove(BaseValidator x) { lock (this.m_root) m_collection.Remove(x); }
/// <summary> /// Removes the first occurrence of a specific <see cref="BaseValidator"/> from the <c>ValidatorCollection</c>. /// </summary> /// <param name="item">The <see cref="BaseValidator"/> to remove from the <c>ValidatorCollection</c>.</param> /// <exception cref="ArgumentException"> /// The specified <see cref="BaseValidator"/> was not found in the <c>ValidatorCollection</c>. /// </exception> public virtual void Remove(BaseValidator item) { int i = IndexOf(item); if (i < 0) throw new System.ArgumentException("Cannot remove the specified item because it was not found in the specified Collection."); ++m_version; RemoveAt(i); }
public override int IndexOf(BaseValidator x) { lock(this.m_root) return m_collection.IndexOf(x); }
public override void Remove(BaseValidator x) { lock(this.m_root) m_collection.Remove(x); }
public override void Remove(BaseValidator x) { throw new NotSupportedException("This is a Read Only Collection and can not be modified"); }
public override bool Contains(BaseValidator x) { lock(this.m_root) return m_collection.Contains(x); }
/// <summary> /// Adds a <see cref="BaseValidator"/> to the end of the <c>ValidatorCollection</c>. /// </summary> /// <param name="item">The <see cref="BaseValidator"/> to be added to the end of the <c>ValidatorCollection</c>.</param> /// <returns>The index at which the value has been added.</returns> public virtual int Add(BaseValidator item) { if (m_count == m_array.Length) EnsureCapacity(m_count + 1); m_array[m_count] = item; m_version++; return m_count++; }
public override bool Contains(BaseValidator x) { return m_collection.Contains(x); }
public override int Add(BaseValidator x) { lock (this.m_root) return(m_collection.Add(x)); }
/// <summary> /// Initializes a new instance of the <c>ValidatorCollection</c> class /// that contains elements copied from the specified <see cref="BaseValidator"/> array. /// </summary> /// <param name="a">The <see cref="BaseValidator"/> array whose elements are copied to the new list.</param> public ValidatorCollection(BaseValidator[] a) { m_array = new BaseValidator[a.Length]; AddRange(a); }
public override bool Contains(BaseValidator x) { lock (this.m_root) return(m_collection.Contains(x)); }
public override bool Contains(BaseValidator x) { return(m_collection.Contains(x)); }
public override int IndexOf(BaseValidator x) { lock (this.m_root) return(m_collection.IndexOf(x)); }
/// <summary> /// Removes the element at the specified index of the <c>ValidatorCollection</c>. /// </summary> /// <param name="index">The zero-based index of the element to remove.</param> /// <exception cref="ArgumentOutOfRangeException"> /// <para><paramref name="index"/> is less than zero</para> /// <para>-or-</para> /// <para><paramref name="index"/> is equal to or greater than <see cref="ValidatorCollection.Count"/>.</para> /// </exception> public virtual void RemoveAt(int index) { ValidateIndex(index); // throws m_count--; if (index < m_count) { Array.Copy(m_array, index + 1, m_array, index, m_count - index); } // We can't set the deleted entry equal to null, because it might be a value type. // Instead, we'll create an empty single-element array of the right type and copy it // over the entry we want to erase. BaseValidator[] temp = new BaseValidator[1]; Array.Copy(temp, 0, m_array, m_count, 1); m_version++; }
public override void CopyTo(BaseValidator[] array, int start) { m_collection.CopyTo(array,start); }
public override int AddRange(BaseValidator[] x) { throw new NotSupportedException("This is a Read Only Collection and can not be modified"); }
public override void Remove(BaseValidator x) { throw new NotSupportedException("This is a Read Only Collection and can not be modified"); }
public override void CopyTo(BaseValidator[] array) { m_collection.CopyTo(array); }
public override int IndexOf(BaseValidator x) { return(m_collection.IndexOf(x)); }
public override int IndexOf(BaseValidator x) { return m_collection.IndexOf(x); }
protected override void Summarize(object sender, SummarizeEventArgs e) { // Don’t validate if no validators were passed if (e.Validators.Count == 0) { return; } BaseContainerValidator extendee = (BaseContainerValidator)sender; ValidationSummaryDisplayMode displayMode = GetDisplayMode(extendee); ValidatorCollection validators = e.Validators; // Make sure there are validators if ((validators == null) || (validators.Count == 0)) { return; } string errorMessage = GetErrorMessage(extendee); string errorCaption = GetErrorCaption(extendee); // Get error text, if provided if (errorMessage == null) { errorMessage = ""; } // Get error caption, if provided if (errorCaption == null) { errorCaption = ""; } // Build summary message body string errors = ""; if (displayMode == ValidationSummaryDisplayMode.Simple) { // Build Simple message errors = errorMessage; } else { // Build List, BulletList or SingleParagraph foreach (object validator in base.Sort(validators)) { BaseValidator current = (BaseValidator)validator; if (!current.IsValid) { switch (displayMode) { case ValidationSummaryDisplayMode.List: errors += string.Format("{0}\n", current.ErrorMessage); break; case ValidationSummaryDisplayMode.BulletList: errors += string.Format("- {0}\n", current.ErrorMessage); break; case ValidationSummaryDisplayMode.SingleParagraph: errors += string.Format("{0}. ", current.ErrorMessage); break; } } } // Prepend error message, if provided if ((errors != "") && (errorMessage != "")) { errors = string.Format("{0}\n\n{1}", errorMessage.Trim(), errors); } } // Display summary message // "if( errors.Trim().Length > 0 )" thanks to John V. Barone and Jorge Matos if (errors.Trim().Length > 0) { MessageBox.Show(errors, errorCaption, MessageBoxButtons.OK, MessageBoxIcon.Warning); } }
public override int AddRange(BaseValidator[] x) { lock(this.m_root) return m_collection.AddRange(x); }
/// <summary> /// Copies the entire <c>ValidatorCollection</c> to a one-dimensional /// <see cref="BaseValidator"/> array, starting at the specified index of the target array. /// </summary> /// <param name="array">The one-dimensional <see cref="BaseValidator"/> array to copy to.</param> /// <param name="start">The zero-based index in <paramref name="array"/> at which copying begins.</param> public virtual void CopyTo(BaseValidator[] array, int start) { if (m_count > array.GetUpperBound(0) + 1 - start) throw new System.ArgumentException("Destination array was not long enough."); Array.Copy(m_array, 0, array, start, m_count); }
public override void CopyTo(BaseValidator[] array, int start) { lock(this.m_root) m_collection.CopyTo(array,start); }
/// <summary> /// Returns the zero-based index of the first occurrence of a <see cref="BaseValidator"/> /// in the <c>ValidatorCollection</c>. /// </summary> /// <param name="item">The <see cref="BaseValidator"/> to locate in the <c>ValidatorCollection</c>.</param> /// <returns> /// The zero-based index of the first occurrence of <paramref name="item"/> /// in the entire <c>ValidatorCollection</c>, if found; otherwise, -1. /// </returns> public virtual int IndexOf(BaseValidator item) { for (int i=0; i != m_count; ++i) if (m_array[i].Equals(item)) return i; return -1; }
public override void Insert(int pos, BaseValidator x) { lock(this.m_root) m_collection.Insert(pos,x); }
/// <summary> /// Inserts an element into the <c>ValidatorCollection</c> at the specified index. /// </summary> /// <param name="index">The zero-based index at which <paramref name="item"/> should be inserted.</param> /// <param name="item">The <see cref="BaseValidator"/> to insert.</param> /// <exception cref="ArgumentOutOfRangeException"> /// <para><paramref name="index"/> is less than zero</para> /// <para>-or-</para> /// <para><paramref name="index"/> is equal to or greater than <see cref="ValidatorCollection.Count"/>.</para> /// </exception> public virtual void Insert(int index, BaseValidator item) { ValidateIndex(index, true); // throws if (m_count == m_array.Length) EnsureCapacity(m_count + 1); if (index < m_count) { Array.Copy(m_array, index, m_array, index + 1, m_count - index); } m_array[index] = item; m_count++; m_version++; }
/// <summary> /// Determines whether a given <see cref="BaseValidator"/> is in the <c>ValidatorCollection</c>. /// </summary> /// <param name="item">The <see cref="BaseValidator"/> to check for.</param> /// <returns><c>true</c> if <paramref name="item"/> is found in the <c>ValidatorCollection</c>; otherwise, <c>false</c>.</returns> public virtual bool Contains(BaseValidator item) { for (int i=0; i != m_count; ++i) if (m_array[i].Equals(item)) return true; return false; }
public override void Insert(int pos, BaseValidator x) { lock (this.m_root) m_collection.Insert(pos, x); }
/// <summary> /// Adds the elements of a <see cref="BaseValidator"/> array to the current <c>ValidatorCollection</c>. /// </summary> /// <param name="x">The <see cref="BaseValidator"/> array whose elements should be added to the end of the <c>ValidatorCollection</c>.</param> /// <returns>The new <see cref="ValidatorCollection.Count"/> of the <c>ValidatorCollection</c>.</returns> public virtual int AddRange(BaseValidator[] x) { if (m_count + x.Length >= m_array.Length) EnsureCapacity(m_count + x.Length); Array.Copy(x, 0, m_array, m_count, x.Length); m_count += x.Length; m_version++; return m_count; }
/// <summary> /// Copies the entire <c>ValidatorCollection</c> to a one-dimensional /// string array. /// </summary> /// <param name="array">The one-dimensional <see cref="BaseValidator"/> array to copy to.</param> public virtual void CopyTo(BaseValidator[] array) { this.CopyTo(array, 0); }