---

DrawMolecule.h

Go to the documentation of this file.

/***************************************************************************
 *cr                                                                       
 *cr            (C) Copyright 1995-2019 The Board of Trustees of the           
 *cr                        University of Illinois                       
 *cr                         All Rights Reserved                        
 *cr                                                                   
 ***************************************************************************/

/***************************************************************************
 * RCS INFORMATION:
 *
 *      $RCSfile: DrawMolecule.h,v $
 *      $Author: johns $        $Locker:  $             $State: Exp $
 *      $Revision: 1.88 $       $Date: 2020/10/28 15:09:56 $
 *
 ***************************************************************************
 * DESCRIPTION:
 *
 * Displayable version of a molecule, derived from BaseMolecule and
 * Displayable.  This contains all the info for rendering the molecule.
 *
 ***************************************************************************/
#ifndef DRAWMOLECULE_H
#define DRAWMOLECULE_H

#include "BaseMolecule.h"
#include "Displayable.h"
#include "DrawMolItem.h"
#include "ResizeArray.h"
#include "WKFThreads.h"
#include "QuickSurf.h"

class AtomColor;
class AtomRep;
class AtomSel;
class VMDApp;
class MoleculeGraphics;
class DrawForce;

// XXX this macro enables code to allow the molecular orbital
// representations within the same molecule to reuse any existing
// rep's molecular orbital grid if the orbital ID and various 
// grid-specific parameters are all compatible.  This optimization
// short-circuits the need for a rep to compute its own grid if
// any other rep already has what it needs.  For large QM/MM scenes,
// this optimization can be worth as much as a 2X speedup when
// orbital computation dominates animation performance.
#define VMDENABLEORBITALGRIDBACKDOOR 1

class DrawMoleculeMonitor {
public:
  // called with id of molecule
  virtual void notify(int) = 0;
  DrawMoleculeMonitor() {}
  virtual ~DrawMoleculeMonitor() {}
};


class DrawMolecule : public BaseMolecule, public Displayable {
public:
  int active;      

  VMDApp *app;     




private:
  int repcounter;  

  MoleculeGraphics *molgraphics;

  DrawForce *drawForce;

#if defined(VMDENABLEORBITALGRIDBACKDOOR)
public:
#endif

  ResizeArray<DrawMolItem *> repList;

#if defined(VMDENABLEORBITALGRIDBACKDOOR)
private:
#endif

  ResizeArray<Timestep *> timesteps;

  int curframe;
 
  int did_secondary_structure;

  ResizeArray<DrawMoleculeMonitor *> monitorlist;

  void addremove_ts();

  float center[3];          
  float scalefactor;        
  
  void update_cov_scale();

  void invalidate_cov_scale();

public:
  DrawMolecule(VMDApp *, Displayable *);
  virtual ~DrawMolecule();

  
  //
  // public utility routines
  //
  wkf_threadpool_t * cpu_threadpool(void);

  wkf_threadpool_t * cuda_devpool(void);
 
  int atom_displayed(int);

  //
  // access routines for the drawn molecule components (which are the children)
  //
  
  int components(void) { return int(repList.num()); }
  
  DrawMolItem *component(int);

  DrawMolItem *component_from_pickable(const Pickable *);

  int get_component_by_name(const char *);
 
  const char *get_component_name(int);
  

  int del_rep(int);

  void add_rep(AtomColor *, AtomRep *, AtomSel *, const Material *);

  int change_rep(int, AtomColor *, AtomRep *, const char *sel);

  int show_rep(int repid, int onoff);

  //causing them to be recomputed on the next access.
  void force_recalc(int);

  void change_pbc();

  void change_ts();

  int highlighted_rep() const;

  //
  // methods for dealing with frames
  //

  int numframes() const { return int(timesteps.num()); }

  int frame() const { return curframe; }

  void override_current_frame(int frame);

  Timestep *current() { 
      if (curframe >= 0 && curframe < timesteps.num())
          return timesteps[curframe];
      return NULL;
  }

  Timestep *get_frame(int n) {
      if ( n>= 0 && n<timesteps.num() ) {
          return timesteps[n];
      }
      return NULL;
  }

  Timestep *get_last_frame() {
      return get_frame(int(timesteps.num())-1);
  }

  void delete_frame(int n);

  void append_frame(Timestep *);

  void duplicate_frame(const Timestep *);

  float scale_factor();

  int cov(float &, float &, float &);

  int recalc_bonds(void);

  int need_secondary_structure(int);

  void invalidate_ss();

  int recalc_ss();

  // return pointer to molgraphics so that MoleculeList::check_pickable
  // can test for it.
  MoleculeGraphics *moleculeGraphics() const { return molgraphics; }

  // prepare molecule for redraw
  virtual void prepare();

  void register_monitor(DrawMoleculeMonitor *);

  void unregister_monitor(DrawMoleculeMonitor *);

  void notify();
};

#endif

---