---

CmdMol.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: CmdMol.h,v $
 *      $Author: johns $        $Locker:  $                $State: Exp $
 *      $Revision: 1.75 $      $Date: 2019/01/17 21:20:58 $
 *
 ***************************************************************************
 * DESCRIPTION:
 * 
 * Command objects for affecting molecules.
 *
 ***************************************************************************/
#ifndef CMDMOL_H
#define CMDMOL_H

#include <string.h>
#include "Command.h"
#include "VMDApp.h"


// the following uses the Cmdtypes MOL_NEW, MOL_DEL, MOL_ACTIVE,
// MOL_FIX, MOL_ON, MOL_TOP, MOL_SELECT, MOL_REP, MOL_COLOR, MOL_ADDREP,
// MOL_MODREP, MOL_DELREP, MOL_MODREPITEM

class CmdMolNew : public Command {
public:
  CmdMolNew() : Command(MOL_NEW) {}
};

class CmdMolLoad : public Command {
protected:
    virtual void create_text();

public:
  int molid;
  char *name;
  char *type;
  FileSpec spec;
  CmdMolLoad(int themolid, const char *thename, const char *thetype, 
      const FileSpec *thespec) 
  : Command(MOL_NEW), molid(themolid), spec(*thespec) {
    name = strdup(thename);
    type = strdup(thetype);
  }
  ~CmdMolLoad() {
    free(type);
    free(name);
  }
};
  

class CmdMolCancel : public Command {
protected:
  virtual void create_text(void);

public:
  int whichMol;
  CmdMolCancel(int molid)
  : Command(MOL_CANCEL), whichMol(molid) {}
};


class CmdMolDelete : public Command {

protected:
  virtual void create_text(void);

public:
  int whichMol;
  CmdMolDelete(int molid)
  : Command(MOL_DEL), whichMol(molid) {}
};


class CmdMolActive : public Command {

protected:
  virtual void create_text(void);

public:
  int whichMol;
  int yn;                

  CmdMolActive(int id, int on)
  : Command(MOL_ACTIVE), whichMol(id), yn(on) {}
};


class CmdMolFix : public Command {

protected:
  virtual void create_text(void);

public:
  int whichMol;
  int yn;                

  CmdMolFix(int id, int on) 
  : Command(MOL_FIX), whichMol(id), yn(on) {}
};



class CmdMolOn : public Command {
protected:
  virtual void create_text(void);

public:
  int whichMol;
  int yn;                

  CmdMolOn(int id, int on) 
  : Command(MOL_ON), whichMol(id), yn(on) {}
};



class CmdMolTop : public Command {
protected:
  virtual void create_text(void);

public:
  int whichMol;
  CmdMolTop(int id)
  : Command(MOL_TOP), whichMol(id) {}
};


class CmdMolSelect : public Command {
public:
  char *sel;
  
protected:
  virtual void create_text(void);

public:
  CmdMolSelect(const char *newsel)
  : Command(MOL_SELECT) { sel = strdup(newsel); }
  virtual ~CmdMolSelect(void)      { free(sel); }
};


class CmdMolRep : public Command {
public:
  // new representation command (if NULL, print out current settings)
  char *sel;
  
protected:
  virtual void create_text(void) ;

public:
  CmdMolRep(const char *newsel)
  : Command(MOL_REP) {  sel = strdup(newsel); }
  virtual ~CmdMolRep(void)      { free(sel); }
};


class CmdMolColor : public Command {
public:
  char *sel;
  
protected:
  virtual void create_text(void);

public:
  CmdMolColor(const char *newsel)
  : Command(MOL_COLOR) {  sel = strdup(newsel); }
  virtual ~CmdMolColor(void) { free(sel); }
};


class CmdMolMaterial : public Command {
public:
  char *mat;
  
protected:
  virtual void create_text(void);

public:
  CmdMolMaterial(const char *newmat)
  : Command(MOL_MATERIAL) { mat = strdup(newmat); }
  virtual ~CmdMolMaterial(void)      { free(mat); }
};


class CmdMolAddRep : public Command {

protected:
  virtual void create_text(void);

public:
  int whichMol;
  CmdMolAddRep(int id) 
  : Command(MOL_ADDREP), whichMol(id) {}
};


class CmdMolChangeRep : public Command {
protected:
  virtual void create_text(void);
 
public:
  int whichMol;
  int repn;
  CmdMolChangeRep(int molid, int repid)
  : Command(MOL_MODREP), whichMol(molid), repn(repid) {}
};


class CmdMolChangeRepItem : public Command {

public:
  enum RepData { COLOR, REP, SEL, MAT }; 
  int whichMol;                          
  int repn;                              
  RepData repData;                       
  char *str;                             

protected:
  virtual void create_text(void);

public:
  CmdMolChangeRepItem(int rpos, int id, RepData rd, const char *s)
  : Command(MOL_MODREPITEM), whichMol(id), repn(rpos), repData(rd) {
    str = strdup(s);
  }

  virtual ~CmdMolChangeRepItem(void) { free(str); }
};


class CmdMolRepSelUpdate : public Command {
public:
  int whichMol;
  int repn;
  int onoroff;

protected:
  virtual void create_text();

public:
  CmdMolRepSelUpdate(int rpos, int id, int on)
  : Command(MOL_REPSELUPDATE), whichMol(id), repn(rpos), onoroff(on) {}
};


class CmdMolRepColorUpdate : public Command {
public:
  int whichMol;
  int repn;
  int onoroff;

protected:
  virtual void create_text();

public:
  CmdMolRepColorUpdate(int rpos, int id, int on)
  : Command(MOL_REPCOLORUPDATE), whichMol(id), repn(rpos), onoroff(on) {}
};


class CmdMolDeleteRep : public Command {
public:
  int whichMol;
  int repn;       

protected:
  virtual void create_text(void);

public:
  CmdMolDeleteRep(int rpos, int id) 
  : Command(MOL_DELREP), whichMol(id), repn(rpos) {}
};


class CmdMolReanalyze : public Command {
protected:
  virtual void create_text(void);
 
public:
  int whichMol;
  CmdMolReanalyze(int id) 
  : Command(MOL_REANALYZE), whichMol(id) {}
};


class CmdMolBondsRecalc : public Command {
protected:
  virtual void create_text(void);
 
public:
  int whichMol;
  CmdMolBondsRecalc(int id) 
  : Command(MOL_BONDRECALC), whichMol(id) {}
};

class CmdMolSSRecalc : public Command {
protected:
  virtual void create_text(void);
 
public:
  int whichMol;
  CmdMolSSRecalc(int id) 
  : Command(MOL_SSRECALC), whichMol(id) {}
};

class CmdMolVolume : public Command {
public:
  int whichMol;
  CmdMolVolume(int id)
  : Command(MOL_VOLUME), whichMol(id) {}
};


class CmdMolRename : public Command {
protected:
  virtual void create_text();

public:
  int whichMol;
  char *newname;

  CmdMolRename(int id, const char *nm);
  ~CmdMolRename();
};


class CmdMolShowPeriodic : public Command {
protected:
  virtual void create_text();
public:
  const int whichMol;
  const int repn;
  const int pbc;
  CmdMolShowPeriodic(int mol, int rep, int thepbc)
    : Command(MOL_SHOWPERIODIC), whichMol(mol), repn(rep), pbc(thepbc) {}
};


class CmdMolNumPeriodic: public Command {
protected:
  virtual void create_text();
public:
  const int whichMol;
  const int repn;
  const int nimages;
  CmdMolNumPeriodic(int mol, int rep, int n)
    : Command(MOL_NUMPERIODIC), whichMol(mol), repn(rep), nimages(n) {}
};


class CmdMolShowInstances : public Command {
protected:
  virtual void create_text();
public:
  const int whichMol;
  const int repn;
  const int instances;
  CmdMolShowInstances(int mol, int rep, int theinstances)
    : Command(MOL_SHOWPERIODIC), whichMol(mol), repn(rep), instances(theinstances) {}
};



class CmdMolScaleMinmax : public Command {
protected:
  virtual void create_text();
public:
  const int whichMol;
  const int repn;
  const float scalemin, scalemax;
  const int reset;
  CmdMolScaleMinmax(int mol, int rep, float themin, float themax,int doreset=0)
  : Command(MOL_SCALEMINMAX), whichMol(mol), repn(rep), scalemin(themin),
    scalemax(themax), reset(doreset) {}
};


class CmdMolDrawFrames : public Command {
protected:
  virtual void create_text();
public:
  const int whichMol;
  const int repn;
  const char * framespec;
  CmdMolDrawFrames(int mol, int rep, const char *frametxt)
  : Command(MOL_DRAWFRAMES), whichMol(mol), repn(rep), framespec(frametxt) {}
};


class CmdMolSmoothRep : public Command {
protected:
  virtual void create_text();
public:
  const int whichMol;
  const int repn;
  const int winsize;
  CmdMolSmoothRep(int mol, int rep, int win)
  : Command(MOL_SMOOTHREP), whichMol(mol), repn(rep), winsize(win) {}
};


class CmdMolShowRep : public Command {
protected:
  virtual void create_text();
public:
  const int whichMol;
  const int repn;
  const int onoff;
  CmdMolShowRep(int mol, int rep, int on)
  : Command(MOL_SHOWREP), whichMol(mol), repn(rep), onoff(on) {}
};

#endif

---