  G | Low-level classes for o/s services |
 HexdumpImp | A private scope used for the implementation details of G::hexdump and G::hex_dump |
  hexdump_tohex | Nibble-to-hex-digit functor |
| hexdump_toprintable | Char-to-printable-ascii functor |
| hexdump_ostream_emitter | An output adaptor to write to std::ostream |
 hexdump_streamable | A streamable class used by G::hexdump() |
| PublisherImp | A private scope used in the implementation of G::Publisher and friends |
| path_t | A character array for storing filesystem paths in shared memory |
| Slot | A shared-memory structure used by G::Publisher |
| ControlMemory | A shared-memory structure used by G::Publisher |
| DataMemory | A shared-memory structure used by G::Publisher |
| Lock | A RAII semaphore lock class used by G::PublisherImp |
| SocketHolder | A private implementation class used by G::PublisherImp |
| Snapshot | A private implementation class used by G::PublisherImp |
| InfoSlot | A structure used by G::Publisher, having a sub-set of G::PublisherImp::Slot members, used for diagnostics and error reporting |
| Slot | A typesafe callback library that isolates event sinks from event sources |
| SlotImpBase | Used as a base class to all slot implementation classes (such as G::Slot::SlotImp1), allowing them to be used as bodies to the associated slot reference-counting handle class (eg |
| SignalImp | A static helper class used by G::Slot signal classes |
| SlotImp0 | A slot implementation class for zero-parameter callbacks |
| SlotCallback0 | Provides a function to down-cast from SlotImpBase to SlotImp0 |
| Slot0 | A slot class for zero-parameter callbacks |
| Signal0 | A signal class for zero-parameter callbacks |
| SlotImp1 | A slot implementation class for one-parameter callbacks |
| SlotCallback1 | Provides a function to down-cast from SlotImpBase to SlotImp1 |
| Slot1 | A slot class for one-parameter callbacks |
| Signal1 | A signal class for one-parameter callbacks |
| SlotImp2 | A slot implementation class for two-parameter callbacks |
| SlotCallback2 | Provides a function to down-cast from SlotImpBase to SlotImp2 |
| Slot2 | A slot class for two-parameter callbacks |
| Signal2 | A signal class for two-parameter callbacks |
| SlotImp3 | A slot implementation class for three-parameter callbacks |
| SlotCallback3 | Provides a function to down-cast from SlotImpBase to SlotImp3 |
| Slot3 | A slot class for three-parameter callbacks |
| Signal3 | A signal class for three-parameter callbacks |
| Arg | A class which holds a represention of the argc/argv command line array, and supports simple command-line parsing |
| Base64 | A base64 codec class |
| bit_iterator | A bit-by-bit input iterator that extracts bits in msb-to-lsb order from a sequence of bytes |
| bit_stream | A class for pulling integer values of various widths out of a bit stream |
| Cleanup | A static interface for registering cleanup functions that are called when the process terminates abnormally |
| CleanupImp | A pimple-pattern implementation class used by G::Cleanup |
| Convert | A static class which provides string encoding conversion functions |
| ThrowOnError | Holds context information which convert() adds to the exception when it fails |
| utf8 | A string wrapper that indicates UTF-8 encoding |
| ConvertImp | A pimple-pattern implementation class for G::Convert |
| Daemon | A static interface for daemonising the calling process |
| Date | A date (dd/mm/yyyy) class |
| LocalTime | An overload discriminator class for Date constructors |
| EpochTime | A subsecond-resolution timestamp based on a time_t |
| DateTime | A low-level static class used by Date and Time |
| threading | Helper class for std::thread capabilities |
| Directory | An encapsulation of a file system directory that allows for iterating through the set of contained files |
| DirectoryIterator | A Directory iterator |
| DirectoryList | A Directory iterator with the same kind of interface as G::DirectoryIterator, but doing all file i/o in one go |
| Item | A directory-entry item for G::DirectoryList |
| DirectoryIteratorImp | A pimple-pattern implementation class for DirectoryIterator using opendir()/readdir() |
| DirectoryTree | A directory tree iterator for sorted, depth-first traversal of files and directories |
| DirectoryTreeCallback | A callback interface to allow G::DirectoryTree to ignore paths |
| Environment | A static class to wrap getenv() and putenv() |
| Exception | A general-purpose exception class derived from std::exception and containing a std::string |
| Executable | A structure representing an external program, holding a path and a set of arguments |
| ExpGolomb | Does exp-golomb decoding, as used in H.264 "ue(v)" syntax elements |
| value | Syntactic sugar for extracting ExpGolomb-encoded values |
| FatPipe | A one-way, unreliable-datagram communication channel from a parent process to a child process, using shared memory |
| ControlMemory | Shared memory structure for G::FatPipe |
| DataMemory | Shared memory structure for G::FatPipe |
| Lock | RAII class to lock the G::FatPipe control segment |
| FatPipeReceiver | A class to read a fat pipe in the child process |
| File | A simple static class for dealing with files |
| NoThrow | An overload discriminator class for File methods |
| FileTree | A class for walking files in a directory tree, with repositioning |
| GetOpt | A command line option parser |
| Identity | A combination of user-id and group-id, with a very low-level interface to the get/set/e/uid/gid functions |
| IdentityUser | A convenience class which, when used as a private base, can improve readability when calling Identity 'set' methods |
| Item | A variant class holding a string, an item map keyed by name, or an ordered list of items |
| limits | A scoping structure for a set of buffer sizes |
| LocalSocketAddress | An address class for G::LocalSocket that works with file system paths |
| LocalSocket | And accept()ing should be performed directly on the file descriptor |
| Log | A class for doing iostream-based logging |
| Line | A class for adding line number information to the Log output |
| LogOutput | Controls and implements low-level logging output, as used by the Log interface |
| MapFile | A class for reading and editing key=value files, supporting the creation of backup files, variable expansion, character-set encoding and logging |
| Md5 | MD5 message digest class |
| Masked | An overload discriminator for G::Md5::hmac() |
| Msg | Wrappers for sendmsg() and recvmsg() that are near drop-in replacements for send()/sendto() and recv()/recvto(), but with SIGPIPE disabled and optional file-descriptor-passing capabilities |
| NewProcess | A class for creating new processes |
| NewProcessWaitFuture | A class that holds the parameters and the results of a waitpid() system call |
| Pipe | A private implementation class used by G::NewProcess that wraps a unix pipe |
| NewProcessImp | A pimple-pattern implementation class used by G::NewProcess |
| noncopyable | A noncopyable base class (a la boost) |
| OptionMap | A map-like container for command-line options and their values |
| OptionParser | A parser for command-line arguments that operates according to an Options specification and returns an OptionValue multimap |
| OptionsLevel | Used by G::Options for extra type safety |
| OptionsLayout | Describes the layout for G::Options output |
| Options | A class to represent allowed command-line options and to provide command-line usage text |
| OptionValue | A simple structure encapsulating the value of a command-line option |
| PathImp | A private implementation class used by G::Path providing a set of static methods |
| Path | A Path object represents a file system path |
| PidFile | A class for creating pid files |
| PublisherInfo | A structure that holds diagnostic information for each G::Publisher slot |
| Publisher | A broadcast communication channel between unrelated processes using shared memory |
| PublisherChannel | A named publisher channel that can be subscribed to |
| PublisherSubscriber | A publication-channel subscriber endpoint |
| PublisherSubscription | An easy-to-use combination of a G::PublisherChannel object and a single G::PublisherSubscriber |
| ReadWrite | An abstract interface for reading and writing from a non-blocking i/o channel |
| Root | A class which acquires the process's special privileges on construction and releases them on destruction |
| Semaphore | A semaphore class with a posix or sysv implementation chosen at build-time |
| storage_type | Semaphore storage |
| SharedMemory | A POSIX shared memory class |
| Control | Overload discriminator for G::SharedMemory |
| SignalSafe | An empty structure that is used to indicate a signal-safe, reentrant implementation |
| Str | A static class which provides string helper functions |
| Limited | Overload discrimiator for G::Str::toUWhatever() |
| StringMapReader | An adaptor for reading a const map<string,string> with at(key) |
| Test | A static interface for enabling test features at run-time |
| Time | A simple time-of-day (hh/mm/ss) class |
| LocalTime | An overload discriminator class for Time constructors |
| Url | A simple parser for URLs |
 Process | A static interface for doing things with processes |
 IdImp | A private implementation class used by G::Process that wraps a process id and hides the pid_t type |
| GNet | Network classes |
| Address | The GNet::Address class encapsulates a TCP/UDP transport address |
| Family | A type-safe enumerator for IP address family |
| AddressStorage | And hiding the definition of sockaddr_storage |
| Address4 | A 'sockaddr' wrapper class for IPv4 addresses |
| union_type | Used by GNet::Address4 to cast between sockaddr and sockaddr_in |
| Address6 | A 'sockaddr' wrapper class for IPv6 addresses |
| union_type | Used by GNet::Address6 to cast between sockaddr and sockaddr_in6 |
| AddressStorageImp | A pimple-pattern implementation class used by GNet::AddressStorage |
| BufferedServerPeer | A ServerPeer that does line-buffering on input |
| Client | A HeapClient class that adds slot/signal signalling, connection/response timeouts, and input line buffering |
| ClientPtr | A smart pointer class for GNet::HeapClient that keeps track of when the contained instance deletes itself |
| Connection | An interface which provides address information for a network connection |
| Descriptor | A class that encapsulates a network file descriptor and hides knowledge of its o/s-spefific error value |
| EventExceptionHandler | An abstract interface for handling exceptions thrown out of event-loop callbacks (socket events and timer events) |
| EventHandler | A base class for classes that handle asynchronous events from the event loop |
| EventHandlerList | A class that maps from a file descriptor to an event handler, used in the implemention of classes derived from GNet::EventLoop |
| Iterator | An iterator for file-descriptor/handler-function pairs in a GNet::EventHandlerList |
| EventLoop | An abstract base class for a singleton that keeps track of open sockets and their associated handlers |
| Running | RAII class that sets a boolean, for implementations of run()/running() |
| FdSet | An "fd_set" wrapper class used by GNet::EventLoopImp |
| FutureEvent | An object that hooks into the event loop and calls back to the client code with a small unsigned integer payload |
| FutureEventHandler | A callback interface for GNet::FutureEvent |
| FutureEventImp | A pimple-pattern implementation class used by GNet::FutureEvent |
| HeapClient | A SimpleClient class for client objects that manage their own lifetime on the heap |
| HttpClientParser | A parser for HTTP responses received from a remote server |
| HttpClientProtocol | A protocol driver for an http client |
| Callback | A callback interface for GNet::HttpClientProtocol to send data and deliver content |
| LineBuffer | A class which does line buffering |
| LineBufferIterator | An iterator class for GNet::LineBuffer that extracts complete lines |
| Local | A static class for getting information about the local machine's network name and address |
| Location | A class that holds a host/service name pair and the preferred address family (if any), and also the results of a name-to-address lookup, ie |
| MonitorImp | A pimple-pattern implementation class for GNet::Monitor |
| Monitor | A singleton for monitoring GNet::SimpleClient and GNet::ServerPeer connections and for storing their TLS certificates |
| Request | A base class for making asynchronous DNS requests under Windows |
| HostRequest | A derivation of GNet::Request used for hostname lookup requests |
| ServiceRequest | A derivation of GNet::Request used for service (port) lookup requests |
| ResolverFuture | Address a = f.get().first ; |
| ResolverImp | A private "pimple" implementation class used by GNet::Resolver to do asynchronous name resolution |
| Resolver | A class for synchronous or asynchronous network name to address resolution |
| Callback | An interface used for GNet::Resolver callbacks |
| ServerPeerHandle | A structure used in the implementation of GNet::Server |
| Server | A network server class which listens on a specific port and spins off ServerPeer objects for each incoming connection |
| PeerInfo | A structure used in GNet::Server::newPeer() |
| ServerPeer | An abstract base class for the GNet::Server's connection to a remote client |
| SimpleClient | A class for making an outgoing connection to a remote server, with support for socket-level protocols such as TLS/SSL and SOCKS 4a |
| Socket | Encapsulates a non-blocking Unix socket file descriptor or a Windows 'SOCKET' handle |
| NoThrow | Overload discriminator class for GNet::Socket |
| AcceptPair | A class which is used to return a new()ed socket to calling code, together with associated information |
| StreamSocket | A derivation of GNet::Socket for a stream socket |
| DatagramSocket | A derivation of GNet::Socket for a datagram socket |
| SocketProtocolImp | A pimple-pattern implementation class used by GNet::SocketProtocol |
| Position | A pointer into the scatter/gather payload of GNet::SocketProtocolImp::send() |
| SocketProtocol | An interface for implementing a low-level TLS/SSL protocol layer on top of a connected non-blocking socket |
| SocketProtocolSink | To deliver data from a socket |
| TimerBase | An interface used by GNet::TimerList to keep track of pending timeouts and to deliver timeout events |
| Timer | A timer class template in which the timeout is delivered to the specified method |
| TimerList | A singleton which maintains a list of all Timer objects, and interfaces to the event loop on their behalf |
| NoThrow | Overload discriminator class for TimerList |
| EventLoopImp | A concrete implementation of GNet::EventLoop using select() in its implementation |
| Gr | Static image classes |
| Avc | Classes for decoding H.264 parameter sets |
| Configuration | Contains AVC configuration parameters, initialised from an "avcC" file segment or from an SDP "fmtp" attribute string, held as lists of SPS and PPS sub-structures |
| Sps | A Sequence Parameter Set (SPS) structure |
| Pps | A Picture Sequence Parameter Set (PPS) structure |
| Rbsp | Provides static helper functions that relate to RBSP formatting |
| ColourSpace | Provides rgb/yuv colourspace mapping functions |
| triple | A 3-tuple for holding rgb or yuv triples |
| cache | A cache for a complete set of rgb/yuv mappings, amounting to about 50MB of data |
| matrix_256_inverse | Rgb-to-yuv matrix using scaled integers where 256 is 1 |
| matrix_256 | Yuv-to-rgb matrix using scaled integers where 256 is 1 |
| matrix_1000_inverse | Rgb-to-yuv matrix using scaled integers where 1000 is 1 |
| matrix_1000 | Yuv-to-rgb matrix using scaled integers where 1000 is 1 |
| range_y | Defines the "digital" range for y component |
| range_uv | Defines the "digital" range for u/v components |
| range_rgb | Defines the "digital" range for r/g/b components |
| fp_1000 | A simple fixed-point number class with a scale factor of 1000 |
| fp_256 | A simple fixed-point number class with a scale factor of 256 |
| converter_double | An adaptor for double |
| converter_fp | An adaptor for fp_# |
| imagebuffer | A namespace for low-level free functions that operate on container classes that are Gr::ImageBuffer candidates |
| imp | A private implementation namespace |
| vectors_streambuf | A simple, read-only streambuf for Gr::Vectors |
| vectors_const_byte_iterator | A forward byte-by-byte input iterator for Gr::ImageVectors |
| traits | A namespace for traits classes |
| imagebuffer | A traits class that can be specialised for Gr::ImageBuffer candidates |
| imagebuffer< Vectors > | Specialisation for Gr::Vectors |
| Colour | A simple rgb colour structure |
| add_size | |
| Glyph | A class for mapping characters to 8x8 glyphs |
| Histogram | A class that does histogram equalisation for eight-bit samples |
| Image | A class holding shared read-only image data (Gr::ImageBuffer) and its associated image type (Gr::ImageType) |
| ImageConverter | An image format converter that can convert to and from the raw and jpeg formats (only), with scaling and monochrome options |
| ImageData | A holder for image data, having eight bits per sample and one or three channels |
| ImageDataWrapper | A class that wraps a read-only image buffer with a few methods that are similar to those of Gr::ImageData |
| ImageDataWriter | |
| ImageDecoder | An interface for decoding encoded images into a raw format |
| ScaleToFit | Describes scale-to-fit target dimensions |
| ImageType | An encapsulation of image type, including width, height and number of channels, with support for a string form that encodes the same information |
| String | A small-string class used for stringised Gr::ImageType instances |
| Jpeg | A scoping class for other jpeg classes |
| JpegInfo | Provides some basic information about a jpeg image without full decoding |
| JpegReader | A read interface for libjpeg |
| JpegWriter | A write interface for libjpeg |
| JpegBufferSource | A libjpeg 'decompression source manager' that reads from Gr::ImageBuffer |
| JpegBufferDestination | A libjpeg 'decompression destination manager' that writes to Gr::ImageBuffer |
| JpegReaderImp | A private implementation class for Gr::JpegReader |
| JpegWriterImp | A private pimple class for Gr::JpegWriter |
| LineDrawImp | A low-level line-drawing class used in the implementation of Gr::LineDraw |
| LineDraw | A class template for drawing lines in terms of separate horizontal line segments |
| Png | A static class providing information about the png library |
| PngInfo | A class that reads a png header in order to provide the image dimensions |
| PngReader | A read interface for libpng |
| PngWriter | An interface for writing a raw dgb image as a png file |
| Output | Abstract interface for Gr::PngWriter::write() |
| PngReaderImp | A private pimple-pattern class for Gr::PngReader |
| PngWriterImp | A private pimple-pattern class for Gr::PngWriter |
| PngImp | A private base class that manages png_struct and png_info structures, and handles error callbacks |
| FileCloser | RAII class to do std::fclose() |
| PngTagsImp | A Gr::PngWriter implementation class that holds tags |
| PnmInfo | A structure holding portable-anymap metadata |
| PnmReader | A static interface for reading portable-anymap (pnm) files |
| ScalerImp | A base class for Gr::Scaler that does scaling using the Bresenham algorithm, but limited to the first quadrant |
| Scaler | A class that allows for iterating over one integer range while accessing values from another, with no requirement for one range to be a multiple of the other, eg |
| GSsl | Stubbed-out TLS/SSL classes |
| Protocol | A TLS protocol class |
| Library | A singleton class for initialising the underlying TLS library |
| Gv | Video classes |
| AvcReaderStream | Holds state for an AVC (aka H.264) decoder |
| AvcReader | A decoder for an AVC (aka H.264) video packet |
| Component | Describes one plane of a Gv::AvcReader image, and points to its data |
| Data | Describes a Gv::AvcReader image, and points to its data via up to four Components |
| Iterator | A row iterator for Gv::AvcReader providing r/g/b or y/u/v across a row |
| SimpleIterator | An optimised row iterator for Gv::AvcReader when simple() |
| AvcReaderStreamImp | A private pimple class for Gv::AvcReaderStream, holding AVCode, AVCodecContext and AVFrame libav objects |
| BarsGenerator | A implementation class for Gv::BarsImp |
| BarsImp | A pimple-pattern implementation class for Gv::Bars |
| Bars | An image generator for test images comprising horizontal or vertical colour bars |
| Cache | A queue of recent images that can be flushed to the filesystem on demand |
| Camera | A high-level webcam interface that hooks into the GNet event loop and acts as an Gv::ImageInputSource |
| Capture | A video capture abstract interface, exposing a file descriptor and a method to handle read events on it |
| CaptureCallback | A callback interface for the Gv::Capture class |
| CaptureTest | A Gv::Capture implementation that serves up dummy frames created by a Gv::ImageGenerator |
| CaptureImp | A private implementation class used by Gv::CaptureV4l |
| CaptureRequeuer | A RAII class to do ioctl(VIDIOC_QBUF) on a v4l buffer |
| CaptureV4l | A video capture implementation for video-for-linux (v4l) |
| CaptureBufferScale | A structure holding capture buffer dimensions |
| CaptureBuffer | A video-capture buffer class to hold image data, with overloaded constructors for the various V4l i/o mechanisms |
| CaptureBufferComponent | A descriptor for one colour component in a Gv::CaptureBufferFormat structure |
| CaptureBufferFormat | A descriptor for a v4l pixel format |
| CaptureBufferIterator | A const iterator for a single row of Gv::CaptureBuffer pixels |
| CaptureFactory | A factory class for G::Capture |
| ClientHolder | Manages a network client object so that the network client is automatically re-created from a factory when it finishes, or alternatively the event loop is quit()ed |
| CommandSocketMixinImp | A pimple-pattern implementation class for Gv::CommandSocketMixin |
| CommandSocket | A non-blocking datagram socket that is used for sending and receiving process control commands |
| NoThrow | Overload descriminator for Gv::CommandSocket |
| Type | Describes a Gv::CommandSocket as a UDP address or unix-domain path |
| CommandSocketMixin | A mixin base class that contains a bound Gv::CommandSocket object integrated with the GNet::EventLoop |
| DatabaseWrapper | A concrete Database class that aggregates up to one second intervals and then delegates to (eg.) DatabaseRrd |
| DatabaseRrd | Manages an rrdtool database under the Gv::Database interface |
| Database | An abstract interface for a timeseries database that holds video analysis statistics |
| DemoImp | A pimple-pattern implementation class for Gv::Demo |
| Demo | An image generator class for a demo animation |
| Exit | A simple exception structure holding a program exit value |
| HttpServerInput | An ImageInput class that integrates with the event loop, with automatic re-opening if the channel goes away for a while |
| HttpServerSource | Used by a ImageInputHandler-derived object to hold a ImageInputSource pointer |
| HttpServerSources | A container for ImageInputSource pointers, used by Gv::HttpServerPeer |
| HttpServerResources | A configuration structure for resources that Gv::HttpServerPeer makes available |
| HttpServerConfig | A configuration structure for Gv::HttpServerPeer holding default settings from the command-line which are then overriden by url parameters |
| HttpServerPeer | A GNet::ServerPeer class for HTTP servers that serves up image streams |
| ImageGenerator | An abstract interface for filling a YUYV capture buffer with a generated image |
| ImageInputConversion | A structure that describes the preferred image type for the Gv::ImageInputHandler callback |
| ImageInputTask | A private implementation class used by Gv::ImageInputSource |
| ImageInputHandler | A callback interface for Gv::ImageInputSource |
| ImageInputSource | A base class for distributing incoming images to multiple client objects, supporting some simple image type conversions |
| ImageInput | A class for reading images from a publication channel and distributing them to multiple client objects |
| ImageOutput | A class for emiting images etc to a fat pipe that feeds a spawned viewer process, and/or to a publication channel, and/or to a filesystem image repository |
| Mask | Implements a binary mask over an image that can be edited by mouse actions, and that can be stored on disk |
| Multicast | A class to do setsocketopt() on a socket file descriptor, with IP_ADD_MEMBERSHIP |
| Overlay | A class that can add a text overlay to an image |
| RibbonRange | Represents a day span within the file store, used by Gv::Ribbon |
| Ribbon | Holds ribbon data that can be used to add a ribbon widget to a video stream display |
| Item | A time bucket within a Gv::Ribbon |
| RtpAvcPacket | An RTP payload parser for the "H264" payload type |
| RtpAvcPacketStream | A class that accumulates RTP-AVC packets and serves up AVC NALUs |
| RtpJpegPacket | An RTP payload parser for the jpeg payload type |
| Payload | A descriptor for the payload within an RTP JPEG packet |
| RtpPacket | An RTP packet parser, as per RFC 3550 (section 5) |
| RtpPacketStream | A class that accumulates RTP-AVC or RTP-JPEG packets and serves up AVC NALUs or JPEG JFIFs |
| RtpServer | An RTP server class |
| RtpServerHandler | A interface that Gv::RtpServer uses to deliver image data |
| Sdp | A parser for a Session Description Protocol block, with a MIME type of "application/sdp" |
| Startup | A handy synthesis of G::LogOutput, G::GetOpt, G::Root, G::Daemon and G::PidFile, used to initialise a server process |
| Timezone | A representation of a timezone |
| ViewerEventMixinImp | A pimple-pattern implementation class for Gv::ViewerEventMixin |
| ViewerEvent | A class for receiving and handling events published from a viewer process |
| Info | A structure representing an interaction event received from a viewer process |
| ViewerEventMixin | A mixin base-class containing a ViewerEvent object that integrates with the GNet::EventLoop |
| ViewerInputHandler | A callback interface for Gv::ViewerInput |
| ViewerInputConfig | A structure to hold configuration for a Gv::ViewerInput object |
| ViewerInput | An input channel for images |
| ViewerWindowConfig | A configuration structure for Gv::ViewerWindow |
| ViewerWindowHandler | A callback interface for Gv::ViewerWindow |
| ViewerWindow | An abstract base class for a viewer window |
| ViewerWindowAnsi | A pimple-pattern implementation class for Gv::ViewerWindow that uses ansi escape sequences |
| ViewerWindowCurses | A pimple-pattern implementation class for ViewerWindow that uses curses |
| ViewerWindowXBase | A private base class for ViewerWindowX that initialises the display before the window is created by the GX::Window base class |
| ViewerWindowX | A pimple-pattern implementation class for ViewerWindow that uses X11 |
| ViewerWindowFactory | A factory class for Gv::ViewerWindow |
| GX | Xlib classes |
| Canvas | A drawing surface that is embedded in a window |
| Capture | RAII class to capture Xlib mouse events |
| ColourMap | A colourmap class that provides pixel values for a set of mapped colours |
| Context | An Xlib GC wrapper |
| Display | An Xlib Display wrapper |
| PixmapFormat | A summary of one item in an Xlib XPixmapFormatValues list |
| Drawable | An abstract base class for xserver-side drawables (windows, pixmaps, etc) with methods for drawing points, lines and blocks |
| Error | An exception class for GX classes |
| EventHandler | An interface for delivering GX::EventLoop events, with do-nothing default method implementations |
| Timeval | A thin wrapper for 'struct timeval' providing relational operators etc |
| EventLoop | An event-loop class that delivers Xlib 'Display' events to GX::Window objects via their GX::EventHandler interface |
| Image | A class for xclient-side images that are drawn locally and then blitted to the xserver |
| Pixmap | A pixmap class for xserver-side images |
| Visual | An Xlib XVisual wrapper |
| Window | A window class that is-a GX::Drawable and a GX::EventHandler |
| WindowMap | A class that can locate a GX::Window object based on a Xlib window handle |
| NotFound | Exception class for GX::WindowMap |
| md5 | Standalone MD5 implementation |
| digest | A class that calculates an md5 digest from one or more 64-byte blocks of data using the algorithm described by RFC 1321 |
| state_type | Holds the md5 algorithm state. Used by md5::digest |
| format | A static string-formatting class for the output of md5::digest |
| block | A helper class used by the md5::digest implementation to represent a 64-character data block |
| digest_stream | A class that calculates an md5 digest from a data stream using the algorithm described by RFC 1321 |
| state_type | Holds the state of an md5 digest stream. Used by md5::digest_stream |
1.8.6 
