Man Linux: Main Page and Category List


       libggi - A fast, simple, small and flexible user-space graphics library


       LibGGI is a  fast,  simple,  small  and  flexible  user-space  graphics
       library  developed by the GGI Project. It attempts to abstract the many
       different graphics output systems  existing  under  Unix  (and  in  the
       future,  other platforms). The support for all of these different types
       of displays and  hardware  are  provided  by  dynamically-loaded  mini-
       libraries.   LibGGI can transparently (to the LibGGI-using application)
       display  graphics  on  an  X  window,  under  SVGAlib,   fbcon   (Linux
       framebuffer  driver),  or  the  glide library, through their respective
       graphics drivers, or targets.  There are also some other targets  which
       display through another target, such as multi to display simultaneously
       on multiple displays  at  once,  and  tile  to  tile  your  display  to
       different monitors.

       LibGGI supports acceleration of graphics primitives where possible.

       LibGGI  is  a  very  generic  piece of software, that will run on about
       every platform that has remotely heard of POSIX (ports to other systems
       such as Win32 are available, too) and on many display subsystems.


       The  following  outlines  the  environment  variables, intended for the
       user, which affect the behaviour of LibGGI:

              If set, LibGGI assumes that you want to use the X target.   This
              setting is overridden by the GGI_DISPLAY variable.

              Specifies  the  default  target  used when the application calls
              ggiOpen(3) with NULL argument.

              The  default  target   is   specified   using   a   target-spec:
              target:targetargs  where  target  is the name of the target, and
              targetargs are any target-specific arguments.

              If neither this variable nor DISPLAY is set, then the  following
              targets are tried in order until one works: fbdev, svga, aa

       GGI_INPUT_target_n, GGI_INPUT_target, GGI_INPUT
              GGI_INPUT_target  specifies  extra  LibGII  input sources and/or
              filters for visuals using target

              Multiple inputs can be specified by enclosing each input-spec in
              parentheses and separating them with semicolons: (i1):(i2):...

              The  inputs  specified  by GGI_INPUT_target_n are only opened at
              the n’th call  of  ggiOpen(3).  This  is  used  for  misbehaving
              applications  that  do  not allow the user to specify inputs for
              the different targets that it opens.

              The GGI_INPUT variable specifies input settings  for  all  other
              targets not specified using the other two variable forms.

              Specifies  the  default mode, which is used for mode negotiation
              with  LibGGI  applications.   Specifically,  when  GGI_AUTO   or
              GT_AUTO  are  specified  in  a  mode  setting  call they will be
              replaced  with  values  from  GGI_DEFMODE  before  calling   the
              target’s own ggiSetMode(3) implementation.

              The format is: (all on one line) S w x h x depth V w x h D w x h
              F frames [scheme depth size]  Anything  and  everything  can  be
              omitted, except tokens indicating what the next token is.

              Any  omitted  values  default  to  GGI_AUTO  (or GT_AUTO for the
              graphtype).  Whitespace and ’.’ symbols are ignored.   Character
              tokens   are   case-insensitive.   If  certain  values  are  not
              possible, they are overridden by the target.

              S      Denotes  the  visible  size  of  the   visual.    Totally
                     optional,   as   dimensions   without   a  specifier  are
                     considered to be the visible dimensions.

                     w and h are the width and height in pixels.

              V      Denotes virtual size, the total drawing area available to
                     the  application.   The  virtual  size  must  be equal or
                     greater than the visible size.

              D      Denotes the number of dots per pixel.  For graphic modes,
                     this  is always 1x1, and for text modes, this is the size
                     of the character cell.

              F      Denotes number of frames available  to  the  application.
                     Applications  can  switch  between  different  frames for
                     double-buffering, etc.

              []     Delimits the graphic type.

                      scheme One of:

                             ·   C : GT_TRUECOLOR

                             ·   P : GT_PALETTE

                             ·   K : GT_GREYSCALE

                             ·   T : GT_TEXT

                      depth  Pixel depth in number of bits.

                      size   Size  of  pixel  in  number  of  bits,  including

                     Instead  of  scheme,  depth, size, it is also possible to
                     specify the graphtype by using one of the following:

                     ·   GT_1BIT

                     ·   GT_2BIT

                     ·   GT_4BIT

                     ·   GT_8BIT

                     ·   GT_15BIT

                     ·   GT_16BIT

                     ·   GT_24BIT

                     ·   GT_32BIT

                     ·   GT_TEXT16

                     ·   GT_TEXT32

              The debugging level for LibGGI:

              0 or unset
                     debug output is off; debugging is off

              255    all debug output is on

              You may also bitwise-or any of the following together:

              ·   2 : debug core

              ·   4 : debug mode setting

              ·   8 : debug color handling

              ·   16 : debug drawing

              ·   32 : misc debugging output

              ·   64 : debug dynamic library handling

              ·   128 : debug event handling

              The debugging output can be quite verbose and in most cases  you
              should  redirect  stderr so that it does not interfere with your
              program’s output.

              Turn  on  synchronous  debugging  output,  flushing  the  output
              buffers before returning from DPRINT calls.

              Override  compiled-in  path  to global config files (Win32 only,
              but not Cygwin).

              If set, causes a new virtual console to be  allocated  for  some
              Linux-console-based targets (currently fbdev and glide).

              This  variable  specifies  the  framerate  for targets emulating
              synchronous mode. The default is 20fps.  If you are experiencing
              problems   with   the  X  target  over  relatively  slow  remote
              connections it might be due to connection  overload.  You  might
              want to try with a lower GGI_MANSYNC_FPS setting.


       Example GGI_DISPLAY settings:

       # see ASCII art flying GGIs

       $ GGI_DISPLAY=aa ./flying_ggis

       # see demo on both machine "crono" next door and local
       # X at the same time

       $ GGI_DISPLAY=multi:(Xlib:crono:0.0):(X::0.0) ./demo

       Example GGI_INPUT string:

       $ export GGI_INPUT=linux-mouse:auto

       # for "multi" target only

       $ export GGI_INPUT_multi=linux-mouse:auto

       Examples of GGI_DEFMODE strings:

       ·   640x480 : just the visible size

       ·   640x480#640x960 : same size, but double-height virtual screen

       ·   #1024x768 : only virtual size defined

       ·   80x40[T] : (default-fontsized) text mode with 80x40 characters

       ·   #x100[T] : text mode with 100 virtual lines

       ·   640x400[8] : 640x400 at 8 bits per pixel

       ·   640x480[GT_8BIT] : same as above, but palettized

       ·   320x200[C15] : 320x200 with 32768 colors (hicolor)

       ·   320x200[C/16] : 320x200 with 16-bit pixels (also hicolor)

       ·   320x200[C24/32],  320x200[GT_32BIT]  :  320x200, with 32-bit pixels
           for 16777216 colors (truecolor)

       ·   640x480F2[GT_16BIT] : 16-bit-color 640x480 with two buffers


       libgii(7),  ggiInit(3),  display-aa(7),  display-directx(7),   display-
       fbdev(7),    display-file(7),    display-glide(7),   display-macosx(7),
       display-memory(7),  display-monotext(7),   display-multi(7),   display-
       palemu(7),    display-sub(7),    display-svgalib(7),   display-tele(7),
       display-tile(7), display-trueemu(7),  display-vcsa(7),  display-vgl(7),