text: 
  
  /* 
  A* -------------------------------------------------------------------
  B* This file contains source code for the PyMOL computer program
  C* Copyright (c) Schrodinger, LLC. 
  D* -------------------------------------------------------------------
  E* It is unlawful to modify or remove this copyright notice.
  F* -------------------------------------------------------------------
  G* Please see the accompanying LICENSE file for further information. 
  H* -------------------------------------------------------------------
  I* Additional authors of this source file include:
  -* 
  -* 
  -*
  Z* -------------------------------------------------------------------
  */
  
  #ifndef _H_Feedback
  #define _H_Feedback
  
  #include"PyMOLGlobals.h"
  
  struct _CFeedback {
    char *Mask;
    char *Stack;
    int Depth;
  };
  
  
  /* 
  
  IMPORTANT DEVELOPER NOTICE:
  
  All non-debugging output should pass through the PRINTF and ENDF
  macros currently defined below, or through the FeedbackAdd or
  FeedbackAutoAdd routines.
  
  Feedback bits are:
  
  Results -- DEFAULT: ON
  
  output from a definite action which gives a result, such as an RMS
  fit, a measured surface area, etc.
  
  Errors -- DEFAULT: ON
  
  complaints which will cause failure at some level.
  
  Actions -- DEFAULT: ON
  
  Output regarding actions in progress or completed, but which
  don't return a particular result.  Example: loading an object or
  creating a selection.
  
  Warnings -- DEFAULT: ON
  
  Questionable situations which will not necessarily result in task
  failure.  Examples: creation of atom selection which includes no
  atoms.  RMS fitting with <4 atoms. 
  
  Details -- DEFAULT: ON
  
  Verbose output reflecting details about what is going on, such as the
  number of primitives in a raytracing scene. DEFAULT: ON
  
  Blather -- DEFAULT: OFF
  
  Output which doesn't fit into the above catogories, and is not likely
  to be required except in extreme cases, but doesn't fall into the
  category of debugging.
  
  Debugging -- DEFAULT: OFF
  
  Text output while would only be of interest to a developer. 
  
  NOTE: Debugging output is the only kind of output which should be sent
  directly to standard output (actually, standard error).
  
  NOTE: Debugging output should always be preceeded b the enclosing
  function name.
  
  */
  
  
  /* WARNING: The following constants are replicated in Python for the purpose
   * of minimize program startup time */
  
  
  /* Discrete Systems and/or Code Modules */
  
  #define FB_All               0  /* only used for setting */
  
  
  /* NOTE, the following don't have to be packed, or in order -- we just
     need to record what the maximum index is.  Rember that that
     feedback architecture is purely a performance hack, so expect some
     inconvenience... 
   */
  
  
  /* layer 0 */
  
  #define FB_Isomesh                   1
  #define FB_Map                       2
  #define FB_Matrix                    3
  #define FB_MyPNG                     4
  #define FB_Triangle                  5
  #define FB_Match                     6
  #define FB_Raw                       7
  #define FB_Isosurface                8
  #define FB_OpenGL                    9
  
  // FB_Shader; no room here
  
  
  /* layer 1 */
  
  #define FB_Color                     10
  #define FB_CGO                       11
  #define FB_Feedback                  12
  #define FB_Scene                     13
  #define FB_Threads                   14 /* part of P.c */
  #define FB_Symmetry                  15
  #define FB_Ray                       16
  #define FB_Setting                   17
  #define FB_Object                    18
  #define FB_Ortho                     19
  #define FB_Movie                     20
  #define FB_Python                    21 /* part of P.c */
  #define FB_Extrude                   22
  #define FB_Rep                       23
  #define FB_Shaker                    24
  
  
  /* layer 2 */
  
  #define FB_CoordSet                  25
  #define FB_DistSet                   26
  #define FB_GadgetSet                 27
  
  #define FB_ObjectMolecule            30
  #define FB_ObjectMap                 31
  #define FB_ObjectMesh                32
  #define FB_ObjectDist                33
  #define FB_ObjectCGO                 34
  #define FB_ObjectCallback            35
  #define FB_ObjectSurface             36
  #define FB_ObjectGadget              37
  #define FB_ObjectSlice               38
  #define FB_ObjectVolume              39
  
  #define FB_RepAngle                  43
  #define FB_RepDihedral               44
  #define FB_RepWireBond               45
  #define FB_RepCylBond                46
  #define FB_RepEllipsoid              47
  #define FB_RepLabel                  48
  #define FB_RepSphere                 49
  #define FB_RepSurface                50
  #define FB_RepMesh                   51
  #define FB_RepDot                    52
  #define FB_RepNonbonded              53
  #define FB_RepNonbondedSphere        54
  #define FB_RepDistDash               55
  #define FB_RepDistLabel              56
  #define FB_RepRibbon                 57
  #define FB_RepCartoon                58
  #define FB_Sculpt                    59
  #define FB_VFont                     60
  // in layer0
  #define FB_Shader                    61
  #define FB_ShaderMgr                 62
  #define FB_ShaderPrg                 63
  
  /* layer 3 */
  
  #define FB_Executive                 70
  #define FB_Selector                  71
  #define FB_Editor                    72
  #define FB_Nag                       73
  
  
  /* layer 4 */
  
  #define FB_Export                    75
  #define FB_CCmd                      76 /* "cmd" is just the python version */
  #define FB_API                       77 /* APIEntry/Exit */
  
  
  /* layer 5 */
  
  #define FB_Main                      80
  
  #define FB_Total                     81 /* highest index + 1 */
  
  
  /* Feedback level bit masks */
  
  #define FB_None            0x00
  
  #define FB_Output          0x01
  
  
  /* python/text output */
  #define FB_Results         0x02
  
  
  /* limited to actual results of an operation...requested measurements, etc. */
  #define FB_Errors          0x04
  #define FB_Actions         0x08
  
  
  /* advisories regarding the completion of a */
  #define FB_Warnings        0x10
  #define FB_Details         0x20
  #define FB_Blather         0x40
  #define FB_Debugging       0x80
  
  #define FB_Everything      0xFF
  
  int FeedbackInit(PyMOLGlobals * G, int quiet);
  void FeedbackFree(PyMOLGlobals * G);
  void FeedbackPush(PyMOLGlobals * G);
  void FeedbackPop(PyMOLGlobals * G);
  
  void FeedbackAutoAdd(PyMOLGlobals * G, unsigned int sysmod, unsigned char mask,
                       char *str);
  void FeedbackAdd(PyMOLGlobals * G, char *str);
  
  void FeedbackSetMask(PyMOLGlobals * G, unsigned int sysmod, unsigned char mask);
  void FeedbackDisable(PyMOLGlobals * G, unsigned int sysmod, unsigned char mask);
  void FeedbackEnable(PyMOLGlobals * G, unsigned int sysmod, unsigned char mask);
  
  
  /* Mechanism: a high-speed bit test, with no range checking 
   * in order to avoid penalizing performance-senstive code
   * modules which may contain live debugging code.  
   */
  
  #define Feedback(G,sysmod,mask) (G->Feedback->Mask[sysmod]&mask)
  
  
  /* FEEDBACK_MAX_OUTPUT should be as small as is reasonable
   * since this much space gets consumed on the stack
   * every time we have a PRINTF macro.  One might consider
   * rewriting these macros to consume heap space instead.
  */
  
  #define FEEDBACK_MAX_OUTPUT 255
  typedef char FeedbackLineType[FEEDBACK_MAX_OUTPUT];
  
  
  /* Print Feedback Macros -- this the most flexible and cross-OS
   * portable solution I've come up with for sending output with
   * variable arguments.
  */
  
  #define PRINTFB(G,sysmod,mask) { FeedbackLineType _FBstr; if(Feedback(G,sysmod,mask)) {(sprintf)( _FBstr,
  #define ENDFB(G) );  FeedbackAdd(G,_FBstr);}}
  
  #define PRINTF { FeedbackLineType _FBstr; (sprintf)( _FBstr,
  #define ENDF(G)  ); FeedbackAdd(G,_FBstr);}
  
  
  /* debugging: goes to stderr */
  
  #define PRINTFD(G,sysmod) {if(Feedback(G,sysmod,FB_Debugging)) { fprintf(stderr,
  #define ENDFD   );fflush(stderr);}}
  
  
  /* convenient vector dumping routine */
  
  #define ENDFD3f(v) );fprintf(stderr,": %8.3f %8.3f %8.3f\n",v[0],v[1],v[2]);fflush(stderr);}}
  
  #endif
  