Technologic - OpenSystems Media

There is a critical subtlety here to be
aware of. Typically the layout utility is
a desktop tool that ultimately generates
code for an embedded platform.
It is important for the interface to look
and behave precisely the same on both
the host development platform and the
platform being developed. The window
builder should enable a What-You-See-
Is-What-You-Get (WYSIWYG) design.
The same runtime library rendering the
image on the desktop should render the
image on the destination device. The
OS shouldn’t, for example, render a font
one way on the desktop OS and appear
differently on the end product. Pixel-forpixel
spacing on a small output device
can matter a great deal.
Creating the code
Once settled on a design, some libraries
make developers write code from
scratch. That’s not the ideal solution. A
good GUI package will generate all the
code and configuration files required
to create the interface. The generated
code should be compiler-neutral, typically
standard ANSI C or C++.
A good bit of the UI’s basic behavior
code can be generated as well. For
example, a collection of radio buttons
has the standard behavior of all turning
off except the one selected. That update
behavior can be coded automatically.
This is not rocket science; programmers
spending time writing basic functionality
wastes their true value.
The functionality behind that interface
is up to the developer. Here the library
can be a great help. This code should
be well documented, showing developers
where to add (and not add) code
to the program. The automatically
generated code should have function
stubs with statements equivalent
to // put your code here. The
designers of the library know what kind
of code belongs where and should provide
a great deal of guidance. Look for
that kind of help in good GUI tools.
carefully for font support in a tool. How
does text get into the UI, and how easy is
it to update and modify that text? What
happens when a client says, “We’re
going after the market in India; we
need to have the software localized into
Hindi”? Developers need to be able to
change the language independently of
the code for smooth system transitions.
Running on hardware
Once the interface is fully designed and
coded, it has to work. It should be compatible
with multiple processors, multiple
display screens with different display
technologies, physical dimensions, and
color depths. It needs to be independent
of hardware assumptions and dependencies
so migration to new platforms and
the addition/removal of components will
not require substantial recoding or redesign.
Input mechanisms should also be
independent – mouse, stylus, capacitive
touch, resistive touch, and so forth. The
library should be software independent
as well, and should work with a choice
of operating systems, drivers, and other
software packages.
Finally, in addition to the actual programming
code, consider UI text. Fonts
in foreign languages and non-Roman
scripts like Mandarin, Kanji, or Arabic
are an important consideration. Look
PC/104 and Small Form Factors 2012 Resource Guide 13