Nano-X
Frequently Asked
Questions Nano-X
Frequently Asked
Questions2010/01/24 Nano-X FAQ - greg [at] censoft.com
There is no difference. In January 2005, the project changed its name from Microwindows to the Nano-X Window System. This is a result of conflicts with Microsoft's registered trademark, Windows.
The Nano-X Window System is an Open Source project that brings some of the features of modern graphical windowing systems to the programming community not wanting or requiring the large disk and ram requirements of higher-end windowing systems like Microsoft Windows or the X Window System. Nano-X does not require any operating system or other graphics system support, as it writes directly to the display hardware, although it runs well on Linux framebuffer systems. Nano-X is designed to be portable, and can run in a wide variety of hardware and software environments. One the of more interesting targets is the emerging market of portable handheld and pocket PC's running Linux, also known as LinuxCE.
Nano-X currently runs on 32-bit Linux systems with kernel framebuffer
support, under the X Window system, or
through the popular SVGAlib library. In addition, it has been ported to 16-bit Linux
ELKS, real-mode and protected mode MSDOS, and the RTEMS real time operating
system. Screen drivers for 1, 2, 4, 8, 16, 24 and 32
bits-per-pixel have been written, as well as a VGA 16 color 4 planes driver.
The Nano-X system has been ported to a number of Handheld and Pocket PC's, as well. The graphics engine is capable of running on any system that supports readpixel,
writepixel, drawhorzline and drawvertline, and setpalette. Blitting support is
optional, but if implemented allows enhanced functionality. All bitmap, font, cursor
and color support is implemented on top of these routines. Support for 8, 15, 16,
24 and
32 bit truecolor systems as well as 1, 2, 4 and 8bpp palletized systems is implemented.
An X11 driver was completed that allows Nano-X applications to be run on
top of the X Window desktop. This driver emulates all of Nano-X's truecolor and
palette modes so that an application can be previewed using the target system's display
characteristics directly on the desktop display, regardless of the desktop display
characteristics. This allows Nano-X graphical applications to be
built and tested on the desktop without having to cross-compile for the target,
with complete emulation of the target's display. If the desktop is running
Linux as well as the target, then the entire application can typically be
tested, as the POSIX api is available on both systems.
The Nano-X Window System is extremely portable, and completely written in C, although some routines have been recoded in assembly for speed. It has been ported to the Intel 16 and 32 bit cpu's, as well as MIPS R4000 (NEC Vr41xx) StrongARM and PowerPC chips found on popular handheld and pocket PC's. There have been rumors of an SH3 port as well.
On 16 bit systems, the entire system, including screen, mouse and keyboard drivers runs in less than 64k. On 32-bit systems, support includes proportional fonts and applications are typically less than 100k.
The Nano-X Window System is essentially a layered design that allows different layers to be used or rewritten to suit the needs of the implementation. At the lowest level, screen, mouse/touchpad and keyboard drivers provide access to the actual display and other user-input hardware. At the mid level, a portable graphics engine is implemented, providing support for line draws, area fills, polygons, clipping and color models. At the upper level, various API's are implemented providing access to the graphics applications programmer. These APIs may or may not provide desktop and/or window look and feel. Currently, Nano-X supports the Win32 and Nano-X APIs. These APIs provide close compatibility with the Win32 and X Window systems, allowing programs to be ported from other systems easily.
Nano-X's origin is with NanoGUI. NanoGUI was created by Alex Holden by taking David Bell's mini-X server and Alan Cox's modifications and adding client/server networking. Greg Haerr then took interest in the NanoGUI project and began making extensive enhancements and modifications to NanoGUI. Around version 0.5, Greg Haerr added support for multiple API's, and began distributing Microwindows. In Microwindows 0.84, all previous NanoGUI changes were incorporated and since then has been the combined NanoGUI/Microwindows distribution. In January 2005, the system changed its name to the Nano-X Window System, with a planned first release as v0.91.
Win32, Microwindows and Nano-X both refer to programs available within the Nano-X Window System. The system supports two APIs, a Win32 compatible API, and an Xlib-like API, known as Nano-X. The Nano-X is used more commonly than the Win32 API under Linux, since Nano-X supports multiple "client" programs accessing a shared graphics server.
Nano-X is the Xlib-like API that the Nano-X Window System supports. It is based on David Bell's mini-X server API, and includes X-like primitives for low-level window and graphics operations. Window management is not included, and the window look and feel must be created through a widget set or directly by the applications programmer. Currently, there are a number of people working on widget sets for Nano-X. There is some discussion about converting the Nano-X API to be X Window System compatible.
The Microwindows API is now known as the Win32 API. The system supports an API based on the Win32 graphics device interface
module, and implements a large portion of it. The function calls try to be 100%
compatible, so that code compiled for other operating systems can usually be
compiled with no source code changes. In addition, a portion of the Win32
USER module is implemented, which contains routines for window dragging, title
bars, message passing, and generating required window messages.
Because of this, window manager support is built into the system, and a single
API for applications programs can be used that doesn't change based on the
widget set being used.
Since the WinCE API is mostly a subset of the Win32 API for graphics-related
functions, the Win32 API is also WinCE compatible, and can be used to
implement WinCE graphics functions on platforms Nano-X is running on.
Nano-X features full RGB color support, color mapping, optimized palette bitmap drawing, truecolor and palletized displays, and a 3d look-and-feel. Overlapped and child windows are supported, with complete window and client area clipping. Proportional and fixed fonts are supported, along with utilities for converting fonts or bitmap files. Optimized painting algorithms are used to allow maximum response while the user is moving windows on the screen. Offscreen drawing and bit-blit routines are implemented for flicker-free drawing and animation. Polygon draws, fills and arbitrary region clipping are also supported.
The project is licensed under the MPL. Alternatively, the software can be licensed under the GPL, if desired. This means that the standard Nano-X distribution can be used for commercial purposes, and supports the needs of developers working under non-disclosure or writing proprietary device drivers. Modifications to source code supplied in the standard distribution must stay open source. Or the entire project can be converted to GPL, with files added by a developer considered GPL only.
The FTP site ftp://microwindows.censoft.com/pub/microwindows is the primary distribution point for all releases. The home web site is at http://microwindows.org. I can be reached at greg [at] censoft.com. There is also a Git source code repository available, along with current snapshot tarballs:
Anonymous read-only access to git repository:
git clone git://microwindows.org/microwin
git clone git://microwindows.org/nxlib
For intended read-write access to git repository: (previous permission required)
git clone git@microwindows.org:microwin
git clone git@microwindows.org:nxlib
For those of you not running git, various tarballs are available via FTP:
Source snapshot (microwindows-src-snapshot.tar.gz)
Fonts snapshot (microwindows-fonts-snapshot.tar.gz)
Full snapshot (microwindows-full-snapshot.tar.gz)
NXLIB snapshot (nxlib-src-snapshot.tar.gz)
There are demos for Linux, ELKS and MSDOS, as well as screenshots, available at:
ftp://microwindows.censoft.com/pub/microwindows/ScreenShots
ftp://microwindows.censoft.com/pub/microwindows/Binaries
The mailing list is nanogui@linuxhacker.org. A web-based signup is available at http://www.linuxhacker.org/nanogui/.
To subscribe, send an empty email to: nanogui-subscribe@linuxhacker.org
To unsubscribe, send an empty email to: nanogui-unsubscribe@linuxhacker.org
Yes you can search through the Nano-X mail list archives. When you make a search add the text "NANOGUI" to filter out other projects hosted on the Linux Hacker server.
There's a framebuffer HOWTO at http://www.tahallah.demon.co.uk/ which should help. In addition, a very useful framebuffer site for developers is http://www.linux-fbdev.org/
One thing that will cause this error error is the inability to create (or delete) the named socket "/tmp/.nano-X". You may have problems with this if one user creates the socket and then nano-X subsequently crashes if you try to run nano-X from another userid you will get this error.
Delete the named socket "/tmp/.nano-X" if it exists, otherwise verify that the userid that is attempting to run nano-X has write permissions to the /tmp directory.
SCANKBD is used to link a keyboard driver that knows the difference between keyup and keydown events, as well as all function and other keys, and reports them separately. This allows complete control of the keyboard, for use in games, etc. TTYKBD uses a very simple ascii-only return values, and won't return function key values correctly.
The mouse type is setup in the Nano-X configuration file, src/config. The mouse type to be used with
Nano-X is set in the config file and the specified mouse driver is then compiled in. Touch panel drivers use the mouse interface with a specific driver. Following are the currently supported mouse types settable in the config file:
GPMMOUSE - use gpm to get mouse input (drivers/mou_gpm.c)
SERMOUSE - the the serial port for mouse input (drivers/mou_ser.c)
TPMOUSE - touch panel driver for Linux-VR compatible kernels and VTech Helio (/dev/tpanel, char special 10,11)
ADSMOUSE - touch panel driver for ADS graphics client (/dev/ts, char special 190,34)
IPAQMOUSE - touch panel driver for iPAQ/Assabet (/dev/h3600_ts, char special 11,0)
NOMOUSE - no mouse/touch panel in system
GPMMOUSE uses the gpm program to get mouse events, SERMOUSE uses the serial port or ps/2 port to get events, and decodes them internal to the mouse driver, drivers/mou_ser.c. If you run GPM, you must use the -R parameter: 'gpm -R -t ps2'
We need help in all sorts of areas. There are currently projects to port base level widget sets and custom controls to Nano-X. Fast screen drivers and blitting routines are also on the list. There are lots of folks interested in getting the system to run on one of the many new Handheld or Pocket PC's. Please join the list and join the fun.