C＃，可访问性和只读

Question

I am working on a relatively complex job management program in C#.

All the data entry forms inherit from a parent that uses the same custom navigation bar (rather similar to the BindingNavigator). By default, none of the data entry controls are enabled when navigating through records. The user has to explicitly enable editing before a record can be edited. This works just fine. However, the reason for me to migrate this entire project was to make the application accessible for screen readers before I finally lose my sight completely.

My problem is that the controls containing the data in the records become completely invisible to the screen reader if they are not enabled. The obvious answer is to make them read-only rather than disabling them, which is fine for text boxes, masked text boxes, NumericUpDown controls, but is not available for checkboxes, radio buttons or combo boxes.

Is there any way to prevent these from being changed while still allowing a screen reader to access them? Or does anyone have a coherent solution for all the controls listed above?

Thanks in advance.

Answer 1

The way that we have handled this in the past in WinForms is to make custom versions of each of the controls and implement readonly on our own.

The basic approach is to intercept the appropriate "changed" event for the control and revert the user's action that they just took when the control has indicated it is to be readonly.

For checkbox, here is a very rough implementation:

public class MyCheckBox : CheckBox
{
    public bool ReadOnly {get; set;}
    private bool m_fInEvent;
    protected override void  OnCheckedChanged(EventArgs e)
    {
        if (ReadOnly) {
            if (!m_fInEvent) {
                try {
                    // Prevent infinite recursion
                    m_fInEvent = true;
                    this.Checked = !this.Checked;
                } finally {
                    m_fInEvent = false;
                } 
            }
        }
        base.OnCheckedChanged(e);
    }
}

Answer 2

Assuming you are using winform, maybe you can use Autocheck for the checkbox.

and for combobox you can try this:

stateComboBox.DropDownStyle = ComboBoxStyle.DropDownList;

Answer 3

I Later realized that the radio buttons in the application were not affected by the problem.

Ultimately, after a lot of difficulty with the ComboBox, I came up with these two classes:

public class ReadOnlyCheckBox : CheckBox
{
    public bool ReadOnly { get; set; }
    protected override void OnKeyUp(KeyEventArgs e)
    {
        if (!ReadOnly)
        {
            base.OnKeyUp(e);
        }
    }
    protected override void OnKeyDown(KeyEventArgs e)
    {
        if (!ReadOnly)
        {
            base.OnKeyDown(e);
        }
    }
    protected override void OnMouseUp(MouseEventArgs e)
    {
        if (!ReadOnly)
        {
            base.OnMouseUp(e);
        }
    }
    protected override void OnMouseDown(MouseEventArgs e)
    {
        if (!ReadOnly)
        {
            base.OnMouseDown(e);
        }
    }
}
public class ReadOnlyComboBox : ComboBox
{
    public bool ReadOnly { get; set; }
    protected override void OnKeyUp(KeyEventArgs e)
    {
        if (ReadOnly)
        {
            e.Handled = true;
        }
        else
            base.OnKeyUp(e);

    }
    protected override void OnKeyDown(KeyEventArgs e)
    {
        if (ReadOnly)
        {
            e.Handled = true;
        }
        else
            base.OnKeyDown(e);
    }
    protected override void OnMouseDown(MouseEventArgs e)
    {
        if (!ReadOnly)
            base.OnMouseDown(e);
        else
        {
            Enabled = false;
            Enabled = true;
            this.Focus();
        }
    }
}

No matter what I tried, the Combo always seemed to handle key and mouse events, even if I didn't call the base methods. hence the different approaches in the two classes.

Both the KeyDown and KeyUp events have to be trapped in the checkbox because by default the KeyDown event grays out the checkbox and the keyup event actually checks the box and restores the normal background.

As far as I can see, it's robust and never allows the state of the controls to change, which could possibly have fired other unwanted actions.