The PEG+ (Portable Embedded GUI) library is a professional quality graphical user interface library created to meet the needs of embedded systems developers. Unlike the alternatives, PEG is small, fast, and easily ported to virtually any hardware configuration capable of supporting graphical output. PEG also delivers exceptional visual appeal and an intuitive and powerful API for application-level user interface development.
PEG+ simply provides the most complete GUI solution available to real-time embedded systems developers. All of the utilities, documentation, support, and development tools you will require for creating a graphical user interface on an embedded system are included with the PEG library development package.
PEG+ is designed to work with any C++ compiler/debugger combination and any embedded CPU supported by RTXC Quadros. PEG+ runs best when using a 16-bit or better CPU running at 16 MHz or higher. Very high resolution or color depth also requires better CPU performance in order to achieve a responsive graphical display. Since PEG+ is provided in source form, you can usually just compile the PEG+ source files, generate the PEG+ library, and link the library into your target software.
PEG+ is delivered with full source code, many example application programs, a complete set of supporting utility programs, hardware interface objects for several common video configurations and input devices, and very thorough documentation to simplify the integration process.
- Programming Model. The PEG+ library is written entirely in C++ and implements an event-driven programming paradigm at the application level.
- Reduced Size. PEG+ achieves a small footprint through several means, including heavy reliance on C++ inheritance to encourage code re-use. A minimum PEG+ footprint requires roughly 50K of code space, 4K of stack, and 2K of dynamic memory. A typical full-featured GUI requires a PEG+ footprint of roughly 100K code, 4K Stack, and 8K of dynamic memory.
- Maximum Performance. PEG+ achieves maximum performance by minimizing the system overhead required to maintain a graphical presentation. This includes support for advanced window and viewport clipping techniques that prevent unnecessary screen drawing. In addition, PEG+ always interacts directly with video and input hardware to achieve the greatest possible throughput.
- Highly Portable. PEG+ achieves portability primarily by abstracting all hardware dependent functionality. The vast majority of the PEG+ library is completely hardware independent, relying on well-defined hardware interface objects to provide a consistent, simple, and reliable set of I/O methods. PEG+ applications are running today on all of the most common embedded processors including ARM, ColdFire, PowerPC, and StrongARM microprocessors. Several working examples supporting the most common display and input types are provided with the library.
- Flexible and Powerful API. The PEG+ library provides an intuitive and robust object hierarchy. Objects may be used directly as provided, or enhanced through user derivation. You will find that you can do things very quickly and easily with PEG+ -- things that would be very difficult and time-consuming using the mainstream desktop GUI programming environments.
The default appearance of PEG+ objects is almost identical to the common desktop graphical environments. This PEG+ API provides robust and intuitive methods for performing even very complex graphical operations.
- Real-Time Awareness. PEG+ is fully integrated with the RTXC Quadros messaging, memory management, and synchronization services. This yields the lowest possible overhead and the only true real-time multi-tasking GUI environment available. PEG+ input devices are interrupt driven, and again use RTXC kernel services to communicate user input information to the graphical user interface.
- Microsoft Windows
PEG+ supports two tasking models to meet the needs of your embedded system.
- PEG+ is configured to execute as a single low-priority task in the overall multi-tasking system such that PEG does not have any effect on the real-time performance of the target system.
- PEG+ may also be configured to support multiple GUI tasks. These tasks can be of differing priorities and can each directly create, display, and control any number of GUI windows or child controls. This advanced capability is unique to the design of PEG+. In this configuration, PEG+ protects internal data structures from corruption through judicial use of RTXC Quadros semaphores. This tasking model has several advantages, the most significant being that the application level programming is greatly simplified. At any time any task in the system can directly display a window or any other type of GUI object and update the information displayed within that object.
- Pointing Device support -- mouse, joystick, and/or touch screen input
- Soft Keys
PEG+ provides industry-leading support for multi-lingual applications.
- Supports two-byte characters and Unicode string encoding.
- CompositeFont technology provides for incorporating even very large character sets in memory-limited embedded systems. Virtually any language can be supported using any combination of character sets including Latin, Cyrillic, Han, Katakana, Hiragana, etc., in a single PEG+ application.
- Full complement of compiler-independent â?�Câ?? string library functions, eliminating the need for any special non-ANSI compiler support for 2-byte characters.
- Complete string table editing and maintenance capabilities with support for JIS and Unicode data entry formats.
PEG+ is designed to take full advantage a broad range of video output devices and display screens.
- Can be configured for monochrome, 4 grays, 16 grays, 16 colors, 256 colors, 65535 colors, and true 24-bit RGB color output.
- Supports a full range of VGA and LCD display devices including LCD devices of unique x-y resolutions or orientations
- Supports hardware acceleration such as hardware cursor or hardware bit-blit.
- Supports double-Buffering.
Screen Driver Templates
A full set of screen driver templates are provided for 1-bpp (monochrome) through 24-bpp (TrueColor RGB) video output. These template drivers are designed to work with any CPU architecture that supports direct, linear access to the video memory buffer Examples of such architectures include:
- Freescale ColdFire
- ARM and StrongARM
- Freescale 68K
Many example configurations for the most common controllers and display devices are provided with the PEG library.
Accelerated Screen Drivers
Many embedded controllers such as those integrated in ARM, and PowerPC CPUs provide integrated video control functionality with limited acceleration features. These controllers work best using one of the template drivers provided with PEG+.
Customized driver classes are currently available for the following video controllers:
- EPSON SPC8106 VGA LCD/CRT Controller
- EPSON SED1330 LCD Controller
- EPSON SED1353 LCD Controller
- EPSON SED1354 LCD/CRT Controller
- EPSON SED1355 LCD/CRT Controller
- EPSON SED1356 LCD/CRT/TV Controller
- EPSON SED1374 LCD Controller
- EPSON SED1375 LCD Controller
- EPSON SED1376 LCD Controller
- EPSON SED1386 LCD/CRT Controller
- Cirrus Logic GD5430 PCI
- Chips & Technology 65535
- Chips & Technology 65545
- Chips & Technology 65550
- Chips & Technology 69000/69030
- 3Dlabs Permedia2 Graphics Controller
- Custom PegScreen drivers for additional video controllers are available on request.
Dvelopment Environment Screen Drivers
The PEG+ development package always ships with the following PegScreen driver classes to facilitate concurrent development:
- Generic VGA- Runs on any PC-compatible in any processor mode.
- VESA SuperVGA- Runs on any PC-compatible in real mode
- Win32- Runs on any PC-compatible running MS Windows 95, 98, or NT.
- X11 â?� Runs on any PC-compatible running X11 R6 including XFree86 3.3.x11
- FontCapture converts TrueType and BDF font files into the native bitmapped font format required internally by PEG+.
- ImageConvert converts .bmp, .gif, and .jpg images into a compressed format supported by the PEG+ bitmap functions.
- WindowBuilder, a powerful visual design tool that allows the developer to quickly create and use custom windows and dialogs.