

/* 
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_PyMOLGlobals
#define _H_PyMOLGlobals

namespace pymol
{
class cif_file;
class cif_data;
}; // namespace pymol

/* retina scale factor for ortho gui */
extern int _gScaleFactor;
inline int DIP2PIXEL(int v) { return v * _gScaleFactor; }
inline float DIP2PIXEL(float v) { return v * _gScaleFactor; }

/* all of the private singleton classes associated with a PyMOL instance */


/* this gets included in virtually every PyMOL source file, so keep it
   short and sweet */

typedef int lexidx_t;
typedef int lexborrow_t;


constexpr unsigned int OrthoLineLength = 1024u;
using OrthoLineType = char[OrthoLineLength];

constexpr unsigned int WordLength = 256u;
using WordType = char[WordLength];

using SelectorID_t = int;
using SelectorMemberOffset_t = int;

using StateIndex_t = int; ///< 0-based state index (C/C++/JavaScript)
using StateIndexPython_t = int; ///< 1-based state index (Python/Settings)

constexpr StateIndex_t cStateAll = -1;
constexpr StateIndex_t cStateCurrent = -2;

typedef struct _CMemoryCache CMemoryCache;
struct CIsosurf;
typedef struct _CTetsurf CTetsurf;
typedef struct _CSphere CSphere;
class CFeedback;
typedef struct _CUtil CUtil;
struct CColor;
struct CMovie;
struct CControl;
struct CButMode;
class COrtho;
typedef struct _CWord CWord;
struct CCGORenderer;
typedef struct _CCharacter CCharacter;
struct CPop;
class CScene;
struct CSeq;
struct CSetting;
struct CSettingUnique;
struct CText;
struct CWizard;
struct CAtomInfo;
typedef struct _CSculptCache CSculptCache;
typedef struct _CVFont CVFont;
typedef struct _CEditor CEditor;
struct CExecutive;
struct CSeeker;
struct CSelector;
struct CSelectorManager;
struct CTexture;
typedef struct _CType CType;
typedef struct _CMain CMain;
struct CPlugIOManager;
struct COpenVR;
struct ObjectMolecule;

class CShaderMgr;
class CMovieScenes;

#ifndef _PYMOL_NOPY
typedef struct _CP_inst CP_inst;
#endif

#ifndef OVLexicon_DEFINED
typedef struct _OVLexicon OVLexicon;
#define OVLexicon_DEFINED
#endif

#ifndef CPyMOLOptions_DEFINED
typedef struct _CPyMOLOptions CPyMOLOptions;
#define CPyMOLOptions_DEFINED
#endif

#ifndef OVCONTEXT_DEFINED
typedef struct _OVContext OVContext;
#define OVCONTEXT_DEFINED
#endif

#ifndef CPyMOL_DEFINED
struct CPyMOL;
#define CPyMOL_DEFINED
#endif

#ifndef CGO_DEFINED
class CGO;
#define CGO_DEFINED
#endif

class GFXManager;

#define cPyMOLGlobals_LaunchStatus_StereoFailed 0x1
#define cPyMOLGlobals_LaunchStatus_MultisampleFailed 0x2

struct PyMOLGlobals {

  /* singleton objects */

  CMemoryCache *MemoryCache;    /* could probably eliminate this... */
  CIsosurf *Isosurf;
  CTetsurf *Tetsurf;
  CSphere *Sphere;
  CFeedback *Feedback;
  CUtil *Util;
  CColor *Color;
  CMovie *Movie;
  CControl *Control;
  CButMode *ButMode;
  COrtho *Ortho;
  CWord *Word;
  CCGORenderer *CGORenderer;
  CCharacter *Character;
  CPop *Pop;
  CScene *Scene;
  CGO *DebugCGO;                /* for debugging rendering */
  CSeq *Seq;
  CSetting *Setting, *Default;
  CSettingUnique *SettingUnique;
  CText *Text;
  CWizard *Wizard;
  CAtomInfo *AtomInfo;
  CSculptCache *SculptCache;
  CVFont *VFont;
  CEditor *Editor;
  CExecutive *Executive;
  CSeeker *Seeker;
  CSelectorManager* SelectorMgr;
  CSelector *Selector;
  CTexture *Texture;
  CType *Type;
  OVContext *Context;
  CMain *Main;                  /* host/platform-specific "main" code */
  CPyMOLOptions *Option;
  CPyMOL *PyMOL;                /* the instance */
  OVLexicon *Lexicon;           /* lexicon for data (e.g. label) strings */
  CPlugIOManager *PlugIOManager;
  CShaderMgr* ShaderMgr;
  COpenVR* OpenVR;
  GFXManager* GFXMgr;
#ifndef _PYMOL_NOPY
  CP_inst *P_inst;
#endif

  /* global variables */

  int HaveGUI;                  /* do we have an OpenGL graphics window or are we
                                 * command-line only? */

  int ValidContext;             /* are we guaranteed to have a valid OpenGL
                                 * context at this exact moment? */

  int Ready;                    /* is the program fully initialized and ready to receive
                                 * messages? */

  int Interrupt;                /* set when we are attempting to abort time-consuming calculations */

  int Terminating;              /* is the program shutting down? */

  /* note that the following four options are also contained in
   * PyMOLOption global -- they exist here as independent globals only
   * because changes haven't yet been made throughout code */

  int StereoCapable;            /* the current graphics context quad buffered? */

  int LaunchStatus;             /* to enable deferred output regarding launch status */

  int Security;                 /* do we warn before potentially executing any
                                 * Python code and ask for their informed consent? */

  int DragDirtyFlag;            /* do we need an extra callback to handle a mouse drag? */

#ifdef _PYMOL_LIB
  void *CallbackObject;
  void (*enabledCallback)(void *, const char *, int );
#endif

  // user defined scenes
  CMovieScenes * scenes;

  // for glDrawBuffer (e.g. GL_BACK, unless we're using QOpenGLWidget)
  int DRAW_BUFFER0;

  struct { lexidx_t
#include "lex_constants.h"
    _; } lex_const;
};


/* if we're running PyMOL as a global singleton (old way / backward
   compatible) then this global variable will contain a pointer to
   PyMOL global state variables */

#ifndef _PYMOL_NOPY
extern PyMOLGlobals *SingletonPyMOLGlobals;
#endif

#endif
