src/ngmx/x11.h

   1 /*
   2  *
   3  *                This source code is part of
   4  *
   5  *                 G   R   O   M   A   C   S
   6  *
   7  *          GROningen MAchine for Chemical Simulations
   8  *
   9  *                        VERSION 3.2.0
  10  * Written by David van der Spoel, Erik Lindahl, Berk Hess, and others.
  11  * Copyright (c) 1991-2000, University of Groningen, The Netherlands.
  12  * Copyright (c) 2001-2004, The GROMACS development team,
  13  * check out http://www.gromacs.org for more information.
  14
  15  * This program is free software; you can redistribute it and/or
  16  * modify it under the terms of the GNU General Public License
  17  * as published by the Free Software Foundation; either version 2
  18  * of the License, or (at your option) any later version.
  19  *
  20  * If you want to redistribute modifications, please consider that
  21  * scientific software is very special. Version control is crucial -
  22  * bugs must be traceable. We will be happy to consider code for
  23  * inclusion in the official distribution, but derived work must not
  24  * be called official GROMACS. Details are found in the README & COPYING
  25  * files - if they are missing, get the official version at www.gromacs.org.
  26  *
  27  * To help us fund GROMACS development, we humbly ask that you cite
  28  * the papers on the package - you can find them in the top README file.
  29  *
  30  * For more info, check our website at http://www.gromacs.org
  31  *
  32  * And Hey:
  33  * Gyas ROwers Mature At Cryogenic Speed
  34  */
  35
  36 #ifndef _x11_h
  37 #define _x11_h
  38
  39 #include <stdio.h>
  40 #include "typedefs.h"
  41 #include "Xstuff.h"
  42
  43 /* These colours will be mapped to black on a monochrome screen */
  44 extern unsigned long BLACK, BLUE, GREEN, CYAN, RED, BROWN, GREY, DARKGREY;
  45
  46 /* These colours will be mapped to white on a monochrome screen */
  47 extern unsigned long LIGHTBLUE, LIGHTGREY, LIGHTGREEN, LIGHTCYAN,
  48                      LIGHTRED, VIOLET, YELLOW, WHITE;
  49
  50 typedef enum {
  51     ecbOK
  52 } ecbReturn;
  53
  54 #define CBARGS (struct t_x11 *x11, XEvent *event, Window w, void *data)
  55 /* Callback function. Return FALSE to continue, TRUE to exit */
  56
  57 typedef struct t_x11 {
  58     Display            *disp;
  59     XFontStruct        *font;
  60     GC                  gc;
  61     Window              root;
  62     char               *dispname;
  63     FILE               *console;
  64     int                 screen, depth;
  65     Colormap            cmap;
  66     unsigned long       fg, bg;
  67     char               *title;
  68     struct t_wlist     *wlist;
  69     void        (*GetNamedColor)(struct t_x11 *x11, const char *name, unsigned long *col);
  70     void        (*MainLoop)(struct t_x11 *x11);
  71     void        (*RegisterCallback)(struct t_x11 *x11, Window w, Window Parent,
  72                                     gmx_bool cb CBARGS, void *data);
  73     void        (*UnRegisterCallback)(struct t_x11 *x11, Window w);
  74     void        (*SetInputMask)(struct t_x11 *x11, Window w, unsigned long mask);
  75     unsigned long       (*GetInputMask)(struct t_x11 *x11, Window w);
  76     void        (*CleanUp)(struct t_x11 *x11);
  77     void        (*Flush)(struct t_x11 *x11);
  78 } t_x11;
  79
  80 typedef gmx_bool CallBack CBARGS;
  81
  82 typedef struct t_wlist {
  83     Window                 w;      /* The window itself                 */
  84     Window                 Parent; /* It's parent window                        */
  85     CallBack              *cb;     /* Call back function                        */
  86     unsigned long          mask;   /* Input mask                                */
  87     void                  *data;   /* User data struct                  */
  88     struct t_wlist        *next;
  89 } t_wlist;
  90
  91 t_x11 *GetX11(int *argc, char *argv[]);
  92 /* x11 is a struct / function-set that manages a number of windows.
  93  * more or (presumably) less like Xt does, but since x11 uses only
  94  * Xlib calls, it is *PORTABLE* software.
  95  *
  96  * The x11 struct is in principle Object Oriented, in that the functions
  97  * are member of the struct. This makes the software a little more
  98  * managable. Because of portability I decided not to use C++, even
  99  * though it would be much nicer to work with in the X-Bizz.
 100  *
 101  * Here's the description of how to use the x11 struct
 102  * 1. Call the GetX11 routine, with the argc and argv from your main.
 103  *    This will sort out the X-arguments on the command line and remove
 104  *    them from the command line. When the routine returns, only the
 105  *    application specific arguments should be left. Thi opens the
 106  *    display, selects a font, creates a Graphics Context and also sets
 107  *    the colours listed above in the global variables.
 108  * 2. Call x11->RegisterCallback for each window you want to have
 109  *    managed by x11. You have to create a Callback routine for your
 110  *    application that handles *ONE* event at a time. The idea is that
 111  *    each window has it's own Callback which is not polluted by code
 112  *    for other windows, but it is of course entirely possible to have
 113  *    one Callback routine for a number of windows (eg. when you need
 114  *    to know something about your children).
 115  * 3. Call x11->SetInputMask. This comes in place of the normal
 116  *    XSelectInput, because it enables x11 to manually decide which
 117  *    events are passed to the windows. With the x11->GetInputMask,
 118  *    x11->SetInputMask combination, a child window can temporarily
 119  *    disable mouse and keyboard input for it's parent, while allowing
 120  *    redraw events to pass through for instance. Hereby a simple way
 121  *    for creating application modal child windows is implemented.
 122  * 4. Call x11->MainLoop. This will call every callback function as
 123  *    appropriate. When a window receives a message, that makes it decide
 124  *    to terminate it should call x11->UnRegisterCallback, in order to
 125  *    tell the x11 Manager that it does not want to receive any more
 126  *    events. It is up to the window to destroy itself. The MainLoop
 127  *    routine exits when there are no more windows to manage, i.e. when
 128  *    all routines have called UnRegisterCallback, OR when one Callback
 129  *    routine returns non-zero (TRUE).
 130  * 5. Call x11->CleanUp. This closes the display, and frees all
 131  *    memory allocated by x11 before.
 132  */
 133
 134 extern void GetNamedColor(t_x11 *x11, const char *name, unsigned long *col);
 135
 136 #endif  /* _x11_h */