How to support the accessibility of open source DUILib

The recent work is to support the accessibility of open source DUILib, and record and share some experiences.

The accessibility of Microsoft is actually a very important thing on the Windows platform. Although it is not valued at home, if your software is exported to Europe and America, accessibility is necessary, otherwise, foreign formal units (government, schools, large companies, etc. ) purchase is prohibited.

If our software uses Winodws standard controls, the system supports general accessibility by default (of course, this is uncertain. According to my test system, the date-time selector control does not support MSAA). Due to some restrictions on the representation and behavior of system standard controls and the complexity of self-drawing, more and more software uses DirectUI technology. See> and:> for reasons for using the DirectUI.

The most famous DirectUI interface library in China is of course the open source DUILib (although this library has stopped updating). In fact, I used to refer to it when I wrote in my spare time. See>. Personally, DUILib, an open source thing, has many advantages and disadvantages. We will focus on the shortcomings, because this is the direction of our improvement.

1。 Poor expansibility

DUILib only implements some basic controls, and a good DirectUI library can easily implement complex controls through the combination of basic controls. In order to achieve this effect, we often need to intercept the messages of child controls. Although DUILib provides a delegation mechanism to subclass child controls, it is too inconvenient to block messages like this, and we often feel dizzy. Personally, I think we can introduce the tunnel and bubbling mechanism of WPF here, which is too important for DirectUI interface library.

2。 Hierarchical windows are not supported.

Perfect support for layered windows means that all renderers must support Alpha channels, and DUILib uses GDI. If there is no special treatment, it means that the layered window cannot be perfectly supported. I also talked about this issue in this article:>.

3。 The performance of big data is not good.

DUILib is often only suitable for simple interfaces. The control base class itself is huge, and the data volume of hundreds of pieces of data is ok, but thousands of pieces of data are too much. At this time, we need to introduce the virtual table mechanism of WPF.

4。 Graphic typesetting is not supported.

Although DUILib supports simple HTML typesetting, it is too simple after all. I can't stand it if we want to introduce it into a chat window like QQ. Besides, I can't stand the code that renders HTML.

5. Accessibility is basically not supported.

6。 other

Interface and attribute definitions are too arbitrary, and the exported class is not easy to extend. In terms of rendering, it is best to switch between GDI/GDI+/Direct2D, and it is best to separate the core control from the extended control. The editor is too simple.

Today, we focus on accessibility. An interface library should fully support accessibility and contain too many things (see "Easy Access Center" in the control panel for details). I estimate that only Microsoft can do it (such as WPF), which is why many people recommend system standard controls and reject DirectUI. What we call accessibility is often just a simplified version. Let's talk about the key points.

1。 Keyboard support

Keyboard support simply means that even if I don't have a mouse, I can complete all the operations through the keyboard. It mainly includes keyboard navigation and keyboard support of controls. Keyboard navigation mainly means that I can switch the focus between different panels through some hot keys (such as F6), and I can navigate the focus between different controls in the window through Tab/Shift+Tab. Many domestic DirectUI libraries also lack keyboard support for controls, such as:

Dialog box: Enter performs the default settings, and ESC exits and closes.

Button: blank execution

Check box: space inversion

Radio: space inversion, and the next key switches the selected items.

TabCtrl: Toggle up, down, left and right when the focus is selected, and Ctrl+Tab/Ctrl+Tab+Shift when the focus is not selected.

Menu: navigate up, down, left and right, press enter, and ESC will cancel closing. See:>

....

In a word, DUILib has done a lot of work in keyboard support, but there are still many things to do. It is a very delicate job for each control to fully support the keyboard.

2。 Screen reading software and automatic test support.

ScreenReader is mainly used for the blind. This program can broadcast the events of controls and systems with focus in real time. Many screen reading softwares need to be charged. Fortunately, after Win7, the system has its own screen reading software (control panel \ easy access \ easy access center \ start narrator). Automated testing also needs to be able to understand the types and locations of elements contained in our interface, as well as tools to simulate operational events.

DirectUI supports screen reading and automated testing in two ways, MSAA and UI automation. MSAA is an old method, which mainly realizes IAccessible interface; UI automation was specially added to WPF by Microsoft. When MSAA came out, it was the winter of' 95. Due to some historical reasons, there are some restrictions, such as not supporting text controls and not being able to describe complex controls, so Microsoft later introduced UI automation. See>.

The biggest advantage of MSAA is stability, so I use MSAA to support DUILib's ScreenReader. Briefly say the following points:

(a) The proxy object that implements the IAccessible interface for each control is as independent as possible, and a reference to the control pointer is saved in it, so that even if the control is destroyed, the proxy object can still exist (the system may still access this object).

(b) According to the hierarchical structure of controls, implement the proxy class of each control (implement IAccessible interface).

(c) When c)WM _ GETOBJECT requests OBJID_CLIENT, it returns the proxy object of the root node, and notifies the trigger event (event _ object _ focus, m _ hwndpaint, (lparam) m _ pfocus, CHILDID_SELF) when the focus changes. When the window receives the WM _ getObject message, it finds the control according to the ObjectID (here, the control pointer). That's the key. This question has been depressing me for a long time. ...

3。 High contrast support.

High contrast is mainly used for color blindness, which is generally not supported by self-drawing programs, even if you use standard controls, because you usually use your own beautiful pictures and colors to express the interface. The key point of high contrast is that when you draw each element, you need to get the color through GetSystemColor. According to my mapping, except for Microsoft's own programs, the more beautiful other software is, the less it supports high contrast (even QQ and Chrome).

4。 High DPI support

With the popularity of Surface Pro and high-resolution devices, the program's support for high DPI becomes more and more important. See:>. Traditional programs based on standard controls are too difficult to support high DPI, so Microsoft has DWM virtualization. But DirectUI has a natural advantage in supporting high DPI. We can make the program perfectly support high DPI at the interface library layer. The rendering of the interface is mainly text, vector and picture. Characters and vectors can be achieved by lossless scaling painting, and images can be achieved by appropriately scaling and changing pictures.

To sum up, although I have complained many times that the DirectUI interface library based on GDI will gradually lose its market with the fading out of XP, I still have to deal with GDI frequently in my practical work, and there are still many positions for Windows client development in outside recruitment units. In this era of "big data" where "mobile internet" and "Web front end" are rampant, many colleagues have begun to transform into mobile apps and big data. Although the developers of PC clients just can't get out in recent years, as long as Windows exists, our work is still valuable. ..

reprint