---

VMDApp.h

Go to the documentation of this file.

/***************************************************************************
 *cr
 *cr            (C) Copyright 1995-2011 The Board of Trustees of the
 *cr                        University of Illinois
 *cr                         All Rights Reserved
 *cr
 ***************************************************************************/
/***************************************************************************
 * RCS INFORMATION:
 *
 *      $RCSfile: VMDApp.h,v $
 *      $Author: kvandivo $        $Locker:  $             $State: Exp $
 *      $Revision: 1.233 $      $Date: 2012/03/13 19:15:25 $
 *
 ***************************************************************************/

// VMDApp
// Instantiate a new VMD object!

#ifndef VMD_APP_H
#define VMD_APP_H

#include "PluginMgr.h"
class Plugin;
class CUDAAccel;
class DisplayDevice;
class SymbolTable;
class Scene;
class PickList;
class PickModeList;
class Axes;
class DisplayRocker;
class CommandQueue;
class UIText;
class MoleculeList;
class GeometryList;
class IMDMgr; 
class Stage;
class Mouse; 
class FPS;
class Animation;
class Mobile; 
class Spaceball; 
#ifdef WIN32
class Win32Joystick;
#endif
class UIVR; 
class FileRenderList;
class VMDTitle;
class MaterialList;
class VMDMenu;
class VMDCollab;

#include <string.h>  // for size_t
#include "NameList.h"
#include "JString.h"
#include "vmdplugin.h"

#define VMD_CHECK_EVENTS  1
#define VMD_IGNORE_EVENTS 0

struct FileSpec {
  int autobonds;    
  int filebonds;    
  int first;        
  int last;         
  int stride;       
  int waitfor;      
  int nvolsets;     
  int *setids;      
  int *selection;   

  FileSpec() {
    autobonds = 1;  // allow automatic bond determination when necessary
    filebonds = 1;  // honor bonds read from loaded files
    first = 0;      // start with first timestep
    last = -1;      // end with last timestep
    stride = 1;     // do every frame
    waitfor = 1;    // wait for frames to load
    nvolsets = -1;  // all volumetric sets
    setids = NULL;  // but no explicit list
    selection = NULL; // default to all atom selected
  }

  FileSpec(const FileSpec &s) {
    autobonds=s.autobonds;
    filebonds=s.filebonds;
    first=s.first;
    last=s.last;
    stride=s.stride;
    waitfor=s.waitfor;
    nvolsets=s.nvolsets;
    if (nvolsets > 0) {
      setids = new int[nvolsets];
      memcpy(setids, s.setids, nvolsets*sizeof(int));
    } else {
      setids = NULL;
    }
    // selections aren't implemented in file loading, and this copy
    // constructor is used only by CmdMolLoad.  Therefore we're ok to
    // just ignore the selection field when making a copy of FileSpec.
    selection = NULL;
  }

  ~FileSpec() {
    delete [] setids;
  }
};


class VMDApp {
public:
  VMDApp(int argc, char **argv);

  int VMDinit(int, char **, const char *, int * dispLoc, int * dispSize);
  
  ~VMDApp();

  void VMDexit(const char *exitmsg, int exitcode, int pauseseconds);
 
private:
#if defined(VMDXPLOR)

  static VMDApp* obj;
#endif

  static JString text_message;

  NameList<VMDMenu *> *menulist; 

  int nextMolID;

  int stride_firsttime;

  int eofexit;  

  int backgroundprocessing;

  Mouse *mouse;
  DisplayRocker *rocker;

  Mobile *mobile;

  Spaceball *spaceball;

#ifdef WIN32

  Win32Joystick *win32joystick;
#endif

  VMDTitle *vmdTitle;
  FileRenderList *fileRenderList;
  PluginMgr *pluginMgr;

public:
  int argc_m;           
  const char **argv_m;  

  // de facto Global variables, by virtual of being public in this singleton
  UIText *uiText;               
  UIVR *uivr;                   
  IMDMgr *imdMgr;               
  Animation *anim;              
  DisplayDevice *display;       
  Scene *scene;                 
  CUDAAccel *cuda;              
  PickList *pickList;           
  PickModeList *pickModeList;   
  MaterialList *materialList;   
  Stage *stage;                 
  Axes *axes;                   
  FPS *fps;                     
  CommandQueue *commandQueue;   
  MoleculeList *moleculeList;   
  GeometryList *geometryList;   
  SymbolTable *atomSelParser;   
  VMDCollab *vmdcollab;         
  NameList<char *> userKeys;    
  NameList<char *> userKeyDesc; 
  int UpdateDisplay;            
  int exitFlag;                 
  int ResetViewPending;         
  char nodename[512];           
  int noderank;                 
  int nodecount;                

  int highlighted_molid, highlighted_rep;

  //
  // NO member variables beyond this point!
  //

  int  background_processing() { return backgroundprocessing; }
  void background_processing_clear() { backgroundprocessing = 0; }
  void background_processing_set()   { backgroundprocessing = 1; }

  void deactivate_uitext_stdin();

  //
  // methods for querying the state of the VMD menus
  //

  int activate_menus();

  int num_menus();               
  const char *menu_name(int);    
  int add_menu(VMDMenu *);    //< add menu.  Return success.
  int remove_menu(const char *); 

  void menu_add_extension(const char *shortname, const char *menu_path);
  void menu_remove_extension(const char *shortname);
  
  int menu_status(const char *name);

  int menu_location(const char *name, int &x, int &y);
 
  int menu_show(const char *name, int on);

  int menu_move(const char *name, int x, int y);
  
  int menu_select_mol(const char *name, int molno);
  
  // 
  // methods for exporting to external rendering systems
  //
  
  int filerender_num();                     
  const char *filerender_name(int n);       
  const char *filerender_prettyname(int n); 
  int filerender_valid(const char *method); 

  const char *filerender_shortname_from_prettyname(const char *pretty);

  int filerender_has_antialiasing(const char *method); 

  int filerender_aasamples(const char *method, int aasamples);

  int filerender_aosamples(const char *method, int aosamples);

  int filerender_has_imagesize(const char *method);

  int filerender_imagesize(const char *method, int *imgwidth, int *imgheight);

  int filerender_aspectratio(const char *method, float *aspect);

  int filerender_numformats(const char *method); 

  const char *filerender_get_format(const char *method, int i);

  const char *filerender_cur_format(const char *method);

  int filerender_set_format(const char *method, const char *format);

  int filerender_render(const char *method, const char *filename,
                        const char *extcmd);

  const char *filerender_option(const char *method, const char *option);
  
  const char *filerender_default_option(const char *method);

  const char *filerender_default_filename(const char *method);

  // 
  // methods for rotating, translating, and scaling the scene.  Return success
  //

  int scene_rotate_by(float angle, char axis, float incr = 0);
  int scene_rotate_to(float angle, char axis);

  int scene_rotate_by(const float *); // takes a float[16]
  int scene_rotate_to(const float *); // takes a float[16]

  int scene_translate_by(float x, float y, float z);
  int scene_translate_to(float x, float y, float z);

  int scene_scale_by(float s);
  int scene_scale_to(float s);

  void scene_resetview_newmoldata();

  void scene_resetview();
 
  int scene_rock(char axis, float step, int nsteps = 0); 
 
  int scene_rockoff();

  int scene_stoprotation();

  int animation_num_dirs();
  const char *animation_dir_name(int);

  int animation_set_dir(int);

  int animation_num_styles();
  const char *animation_style_name(int);

  int animation_set_style(int);

  int animation_set_frame(int frame);

  int animation_set_stride(int);

  int animation_set_speed(float);


  //
  // Methods for getting plugins
  //

  vmdplugin_t *get_plugin(const char *type, const char *name);
  
  int list_plugins(PluginList &, const char *type = NULL);

  int plugin_dlopen(const char *filename);

  void plugin_update();

  //
  // display update methods
  //

  void display_update_on(int);

  int display_update_status();

  void display_update();
  
  void display_update_ui();

  //
  // methods for setting display properties
  // These should be considered provisional; they are here primarily to
  // allow startup options to be processed outside of VMDApp.
  //

  void display_set_screen_height(float);
  float display_get_screen_height();
   
  void display_set_screen_distance(float);
  float display_get_screen_distance();
 
  void display_set_position(int x, int y);
  //void display_get_position(int *x, int *y); // XXX doesn't work...
 
  void display_set_size(int w, int h);
  void display_get_size(int *w, int *h);

  int display_set_stereo(const char *mode);

  int display_set_stereo_swap(int onoff);

  int display_set_cachemode(const char *mode);

  int display_set_rendermode(const char *mode);

  int display_set_eyesep(float sep);

  int display_set_focallen(float flen);

  int display_set_projection(const char *proj);

  int display_projection_is_perspective(void);

  int display_set_aa(int onoff);
  int display_set_depthcue(int onoff);
  int display_set_culling(int onoff);
  int display_set_fps(int onoff);
  int display_set_background_mode(int mode);

  // set clipping plane position.  if isdelta, then treat as offset.
  int display_set_nearclip(float amt, int isdelta);
  int display_set_farclip(float amt, int isdelta);

  int stage_set_location(const char *);
  int stage_set_numpanels(int);
  int stage_set_size(float);

  int axes_set_location(const char *);

  int light_on(int lightnum, int onoff);
  int light_highlight(int lightnum, int onoff);
  int light_rotate(int lightnum, float amt, char axis);
  int light_move(int lightnum, const float *newpos);

  // XXX need to implement all of the advanced lights APIs here too...

  int depthcue_set_mode(const char *);
  int depthcue_set_start(float);
  int depthcue_set_end(float);
  int depthcue_set_density(float);

  int display_set_shadows(int onoff);
  int display_set_ao(int onoff);
  int display_set_ao_ambient(float a);
  int display_set_ao_direct(float d);
  

  // 
  void display_titlescreen();

  // 
  // Methods for setting color properties.  We have a set of color 
  // _categories_ (Display, Axes...), each of which contains one or more
  // _items_ (Display->Background, Axes->X, Y, Z, ...).  Each item has a
  // color _name_ mapped to it (blue, red, ...).
  //

  int num_color_categories();

  const char *color_category(int);

  int color_add_item(const char *cat, const char *item, const char *defcolor); 
  
  int num_color_category_items(const char *category);

  const char *color_category_item(const char *category, int);

  int num_colors();

  int num_regular_colors();

  const char *color_name(int n);

  int color_index(const char *);

  int color_value(const char *colorname, float *r, float *g, float *b);

  int color_default_value(const char *colorname, float *r, float *g, float *b);
  
  const char *color_mapping(const char *category, const char *item);
 
  const char *color_get_restype(const char *resname);

  int color_set_restype(const char *resname, const char *newtype);

  int colorscale_info(float *midpoint, float *min, float *max); 

  int num_colorscale_methods();
  int colorscale_method_current();
  const char *colorscale_method_name(int);

  int colorscale_method_index(const char *);

  int get_colorscale_colors(int whichScale, 
      float min[3], float mid[3], float max[3]);
  int set_colorscale_colors(int whichScale, 
      const float min[3], const float mid[3], const float max[3]);
  

  int color_changename(const char *category, const char *colorname,
                       const char *color);
  
  int color_get_from_name(const char *category, const char *colorname,
                       const char **color);
 
  int color_changevalue(const char *color, float r, float g, float b);

  int colorscale_setvalues(float midpoint, float min, float max);

  int colorscale_setmethod(int method);

  //
  // Command logging methods
  //
  
  int logfile_read(const char *path);
  
  int save_state();
 
  int textinterp_change(const char *interpname);

  // 
  // Methods for editing and querying molecules and molecular representations
  //
 
  int num_molecules();

  int molecule_new(const char *name, int natoms, int docallbacks=1);

  const char *guess_filetype(const char *filename);

  int molecule_load(int molid, const char *filename, const char *filetype, 
      const FileSpec *spec);

  int molecule_add_volumetric(int molid, const char *dataname, 
    const float origin[3], const float xaxis[3], const float yaxis[3],
    const float zaxis[3], int xsize, int ysize, int zsize, float *datablock);

  int molecule_savetrajectory(int molid, const char *filename, 
                              const char *filetype, const FileSpec *spec);

  int molecule_deleteframes(int molid, int first, int last, int stride);

  int molecule_index_from_id(int molid);

  int molecule_id(int);

  int molecule_valid_id(int molid);

  int molecule_numatoms(int molid);

  int molecule_numframes(int molid);

  int molecule_frame(int molid);

  int molecule_dupframe(int molid, int frame);
  
  const char *molecule_name(int molid);
  int molecule_rename(int molid, const char *newname);

  int molecule_cancel_io(int molid);
  
  int molecule_delete(int molid);

  int molecule_delete_all(void);
  
  int molecule_activate(int molid, int onoff);
  int molecule_is_active(int molid);
 
  int molecule_fix(int molid, int onoff);
  int molecule_is_fixed(int molid);
 
  int molecule_display(int molid, int onoff);
  int molecule_is_displayed(int molid);

  int molecule_make_top(int molid);

  int molecule_top(); 

  int num_molreps(int molid);

  //
  // For the molrep methods, repid is not unique; it applies to different reps
  // if reps are created and then deleted.  Too bad.
  //

  const char *molrep_get_style(int molid, int repid); 
  int molrep_set_style(int molid, int repid, const char *style);
 
  const char *molrep_get_color(int molid, int repid); 
  int molrep_set_color(int molid, int repid, const char *color);

  const char *molrep_get_selection(int molid, int repid); 
  int molrep_set_selection(int molid, int repid, const char *selection);

  int molrep_numselected(int molid, int repid);

  const char *molrep_get_material(int molid, int repid); 
  int molrep_set_material(int molid, int repid, const char *material);

  int num_clipplanes();

  int molrep_get_clipplane(int molid, int repid, int clipid, float *center, 
                           float *normal, float *color, int *mode);
  int molrep_set_clipcenter(int molid, int repid, int clipid, 
                            const float *center);
  int molrep_set_clipnormal(int molid, int repid, int clipid, 
                            const float *normal);
  int molrep_set_clipcolor(int molid, int repid, int clipid, 
                            const float *color);
  int molrep_set_clipstatus(int molid, int repid, int clipid, int onoff);
  
  int molrep_set_smoothing(int molid, int repid, int n);

  int molrep_get_smoothing(int molid, int repid);
  
  // methods for retrieving reps by name rather than index.  The name is
  // guaranteed to be unique within a given molecule and follow the rep
  // around even when its order or index changes.
  
  const char *molrep_get_name(int molid, int repid);
  
  int molrep_get_by_name(int molid, const char *);
 
  int molrep_set_pbc(int molid, int repid, int pbc);

  int molrep_get_pbc(int molid, int repid);

  int molrep_set_pbc_images(int molid, int repid, int n);

  int molrep_get_pbc_images(int molid, int repid);

  int molrep_show(int molid, int repid, int onff);

  int molrep_is_shown(int molid, int repid);

  // The next few commands set/get a default representation parameter; these
  // parameters define the properties of the rep which would be added on the
  // next call to molecule_addrep().  They exactly parallel the methods for
  // changing an existing representation except that no molid or repid is
  // specified.
  
  const char *molecule_get_style(); 
  int molecule_set_style(const char *style);
 
  const char *molecule_get_color(); 
  int molecule_set_color(const char *color);

  const char *molecule_get_selection(); 
  int molecule_set_selection(const char *selection);

  const char *molecule_get_material(); 
  int molecule_set_material(const char *material);

  int molecule_addrep(int molid);
  
  int molecule_modrep(int molid, int repid);

  int molrep_delete(int molid, int repid);
 



  int molrep_get_selupdate(int molid, int repid);
  int molrep_set_selupdate(int molid, int repid, int onoff);


  int molrep_get_colorupdate(int molid, int repid);
  int molrep_set_colorupdate(int molid, int repid, int onoff);


  int molrep_get_scaleminmax(int molid, int repid, float *min, float *max);
  int molrep_set_scaleminmax(int molid, int repid, float min, float max);
  int molrep_reset_scaleminmax(int molid, int repid);
  
  int molrep_set_drawframes(int molid, int repid, const char *framesel);
  const char *molrep_get_drawframes(int molid, int repid);

  int molecule_set_dataset_flag(int molid, const char *dataflagstr, int setval);

  int molecule_reanalyze(int molid);

  int molecule_bondsrecalc(int molid);

  int molecule_ssrecalc(int molid);
   
  int molecule_orblocalize(int molid, int waveid);

  // 
  // IMD methods
  //
  
  int imd_connect(int molid, const char *host, int port);

  int imd_connected(int molid);

  int imd_sendforces(int, const int *, const float *);

  int imd_disconnect(int molid);

  // 
  // MPI related parallel processing routines
  //

  const char * par_name() { return nodename; }

  int par_rank() { return noderank; }

  int par_size() { return nodecount; }

  void par_barrier();

  //
  // Tool methods
  //

  int tool_create(const char *type, int argc, const char **argv);
  int tool_delete(int toolnum);
  int tool_change_type(int toolnum, const char *type);
  int tool_set_position_scale(int toolnum, float newval);
  int tool_set_force_scale(int toolnum, float newval);
  int tool_set_spring_scale(int toolnum, float newval);

  //
  // Methods for adding/querying labels
  //

  int label_add(const char *category, int num_ids, const int *molids, 
      const int *atomids, const int *cells, float k, int toggle);

  int label_show (const char *category, int n, int onoff);

  int label_delete(const char *category, int n);

  float label_get_text_size() const;
  int label_set_text_size(float);
  float label_get_text_thickness() const;
  int label_set_text_thickness(float);

  int label_set_textoffset(const char *nm, int n, float x, float y);
  int label_set_textformat(const char *nm, int n, const char *format);

  int next_molid() { return nextMolID++; }

  //
  // Material methods
  //

  const char *material_add(const char *name, const char *copyfrom);

  int material_delete(const char *name);

  int material_change(const char *name, int property, float val);

  int material_rename(const char *oldname, const char *newname);

  int material_restore_default(int);

  int mouse_set_mode(int mode, int setting);


  int mobile_set_mode(int mode);

  int mobile_get_mode();

  void mobile_get_client_list(ResizeArray <JString*>* &nick, 
                         ResizeArray <JString*>* &ip, ResizeArray <bool>* &active);

  int mobile_network_port(int port);

  int mobile_get_network_port();

  int mobile_get_APIsupported();

  int mobile_set_activeClient(const char *nick, const char *ip);

  int mobile_sendMsg(const char *nick, const char *ip, const char *msgType, const char *msg);

  void mobile_get_tracker_status(float &tx, float &ty, float &tz, 
                                 float &rx, float &ry, float &rz, 
                                 int &buttons);

  int spaceball_set_mode(int mode);

  int spaceball_set_sensitivity(float s);

  int spaceball_set_null_region(int nr);

  void spaceball_get_tracker_status(float &tx, float &ty, float &tz, 
                                    float &rx, float &ry, float &rz, 
                                    int &buttons);

  void show_stride_message();

  char *vmd_choose_file(const char *title, 
                const char *extension,
                const char *extension_label,
                int do_save);

  static unsigned long get_repserialnum(void);
  static unsigned long get_texserialnum(void);

  int VMDupdate(int);

  static void set_text(const char* str) { 
     text_message = str; 
  }
  static void append_text(const char* str) { 
     text_message += str; 
  }
  static void clear_text() { 
     text_message = JString(); 
  }
  static const char* get_text() { 
     return text_message; 
  }

  void set_mouse_callbacks(int on);

  void set_mouse_rocking(int on);

  // get/set eofexit status
  void set_eofexit(int onoff) { eofexit = onoff; }
  int get_eofexit() { return eofexit; }

#if defined(VMDXPLOR)

  static VMDApp* Obj() { return obj; }
#endif
};

  extern "C" void * (*vmd_alloc)(size_t);
  extern "C" void (*vmd_dealloc)(void *);
  extern "C" void * (*vmd_realloc)(void *, size_t);
  extern "C" void * vmd_resize_alloc(void * ptr, size_t oldsize, size_t newsize);
#endif

---