---

VMDApp.C

Go to the documentation of this file.

/***************************************************************************
 *cr
 *cr            (C) Copyright 1995-2008 The Board of Trustees of the
 *cr                        University of Illinois
 *cr                         All Rights Reserved
 *cr
 ***************************************************************************/
/***************************************************************************
 * RCS INFORMATION:
 *
 *      $RCSfile: VMDApp.C,v $
 *      $Author: johns $        $Locker:  $             $State: Exp $
 *      $Revision: 1.412 $      $Date: 2008/08/06 20:27:53 $
 *
 ***************************************************************************/
 
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <ctype.h> // for isalnum()

#include "VMDDisplayList.h"
#include "CoorPluginData.h"
#include "PluginMgr.h"
#include "MolFilePlugin.h"
#include "Matrix4.h"
#include "config.h"
#include "Inform.h"
#include "AtomSel.h"
#include "VMDTitle.h"
#include "DisplayDevice.h"
#include "PickList.h"
#include "PickModeList.h"
#include "MaterialList.h"
#include "Scene.h"
#include "CommandQueue.h"
#include "UIText.h"
#include "Stage.h"
#include "Axes.h"
#include "DisplayRocker.h"
#include "FPS.h"
#include "MoleculeList.h"
#include "Mouse.h"
#include "Spaceball.h"
#ifdef WIN32
#include "Win32Joystick.h"
#endif
#include "GeometryList.h"
#include "FileRenderer.h"
#include "FileRenderList.h"
#include "CmdAnimate.h"
#include "CmdMol.h"
#include "CmdMaterial.h"
#include "CmdPlugin.h"
#include "CmdRender.h"   // to log the render commands we execute
#include "CmdTrans.h"
#include "CmdDisplay.h"
#include "CmdColor.h"
#include "CmdLabel.h"
#include "TextEvent.h"
#include "CmdMenu.h"
#include "P_UIVR.h"
#include "P_CmdTool.h"
#include "SymbolTable.h"
#include "VMDCollab.h"
#include "CUDAAccel.h"

#if defined(VMDTHREADS) // System-specific threads code
#include "VMDThreads.h"
#endif

#ifdef MACVMD
#include "MacVMDDisplayDevice.h"
#endif

#ifdef VMDOPENGL        // OpenGL-specific files
#if defined(VMDFLTKOPENGL)
#include "FltkOpenGLDisplayDevice.h"
#else
#ifndef MACVMD
#include "OpenGLDisplayDevice.h"
#endif
#endif

#ifdef VMDCAVE          // CAVE-specific files
#include "cave_ogl.h"
#include "CaveDisplayDevice.h"
#include "CaveRoutines.h"
#include "CaveScene.h"
#endif // VMDCAVE
#endif // VMDOPENGL

#include "VMDMenu.h"
#ifdef VMDFLTK         // If using FORMS GUI include FORMS-specific objects
#include "FL/forms.H"

// New Fltk menus 
#include "MainFltkMenu.h"
#include "ColorFltkMenu.h"
#include "MaterialFltkMenu.h"
#include "DisplayFltkMenu.h"
#include "FileChooserFltkMenu.h"
#include "SaveTrajectoryFltkMenu.h"
#include "GeometryFltkMenu.h"
#include "GraphicsFltkMenu.h"
#include "RenderFltkMenu.h"
#include "ToolFltkMenu.h"

#endif // VMDFLTK

#ifdef VMDIMD
#include "IMDMgr.h"
#include "CmdIMD.h"
#endif

// FreeVR conflicts with the FLTK include files, so include it _after_ FLTK.
#ifdef VMDFREEVR     // FreeVR-specific files
#include "freevr.h"
#include "FreeVRDisplayDevice.h"
#include "FreeVRRoutines.h"
#include "FreeVRScene.h"
#endif

#if defined(VMDTKCON)
#include "vmdconsole.h"
#endif

#include "VMDApp.h"

// default atom selection
#define DEFAULT_ATOMSEL "all"

// XXX static data item
static unsigned long repserialnum;
static unsigned long texserialnum;

// static initialization
JString VMDApp::text_message;

VMDApp::VMDApp(int argc, char **argv) {
  // initialize ALL member variables
  argc_m = argc;
  argv_m = (const char **)argv;
  menulist = NULL;
  nextMolID = 0; 
  stride_firsttime = 1;
  eofexit = 0;
  mouse = NULL;
  spaceball = NULL;
#ifdef WIN32
  win32joystick = NULL;
#endif
  vmdTitle = NULL; 
  fileRenderList = NULL;
  pluginMgr = NULL;
  uiText = NULL;
  uivr = NULL;
#ifdef VMDIMD
  imdMgr = NULL;
#endif
  display = NULL;
  scene = NULL;
  pickList = NULL;
  pickModeList = NULL;
  materialList = NULL;
  stage = NULL;
  axes = NULL;
  fps = NULL;
  commandQueue = NULL;
  moleculeList = NULL;
  geometryList = NULL;
  atomSelParser = NULL;
  anim = NULL;

  UpdateDisplay = TRUE;
  exitFlag = TRUE;
  ResetViewPending = FALSE;

  background_processing_clear();

  highlighted_molid  = highlighted_rep = -1;
}

// initialization routine for the library globals
int VMDApp::VMDinit(int argc, char **argv, const char *displaytype, 
                    int *displayLoc, int *displaySize) {

  // register CUDA GPU accelerator devices
  cuda = new CUDAAccel();

  // initialize the display
  int *dloc = (displayLoc[0]  > 0 ? displayLoc  : (int *) NULL);

  int dsiz[2] = { 512, 512 };
  if (displaySize && displaySize[0] > 0 && displaySize[1] > 0) {
    dsiz[0] = displaySize[0];
    dsiz[1] = displaySize[1];
  }

  // initialize static data items
  repserialnum = 0; // initialize the display list serial number
  texserialnum = 0; // initialize the texture list serial number

#ifdef MACVMD
  display = new MacVMDDisplayDevice(this, dsiz);
#endif

  // check for a standard monitor display
  if (!strcmp(displaytype, "WIN") || !strcmp(displaytype, "OPENGL")) {
#if defined(VMDOPENGL)
#if defined(VMDFLTKOPENGL)
    display = new FltkOpenGLDisplayDevice(argc, argv, this, dsiz, dloc);
#else
    display = new OpenGLDisplayDevice;
    if (!display->init(argc, argv, this, dsiz, dloc)) {
      VMDexit("Unable to create OpenGL window.", 1, 7);
      return FALSE;
    } 
#endif
#endif
  }

#ifdef VMDCAVE
  if (!strcmp(displaytype, "CAVE") || !strcmp(displaytype, "CAVEFORMS")) {
    // The CAVE scene is allocated from shared memory and can be 
    // accessed by all of the rendering processes by virtue of its
    // class-specific operator new.
    scene = new CaveScene(this);
    msgInfo << "Cave shared memory scene created." << sendmsg;

    // the CAVE display device is created in process-private memory
    display = new CaveDisplayDevice;

    // set up pointers for cave_renderer, needs to be done before forking.
    set_cave_pointers(scene, display);

    // XXX this may cure a problem with specular highlights in CAVElib
    // by default CAVElib messes with the OpenGL modelview matrix, this
    // option prevents it from doing so, which should allow specular 
    // highlights to look right on multiple walls, but it breaks depth cueing.
    // CAVESetOption(CAVE_PROJ_USEMODELVIEW, 0);
    CAVESetOption(CAVE_GL_SAMPLES, 8); // enable multisample antialiasing
    CAVEInit();                        // fork off the rendering processes
    CAVEDisplay(cave_renderer, 0);     // set the fctn ptr for the renderers
    display->renderer_process = 0;     // this proc is the master process
    vmd_set_cave_is_initialized();     // flag successfull CAVE init
    msgInfo << "CAVE Initialized" << sendmsg;
  }
#endif

#ifdef VMDFREEVR
  if (!strcmp(displaytype, "FREEVR") || !strcmp(displaytype, "FREEVRFORMS")) {
    // The FreeVR scene is allocated from shared memory and can be 
    // accessed by all of the rendering processes by virtue of its
    // class-specific operator new.
    scene = new FreeVRScene(this);
    msgInfo << "FreeVR shared memory scene created." << sendmsg;

    // the FreeVR display device is created in process-private memory
    display = new FreeVRDisplayDevice;

    // set up pointers for freevr_renderer, needs to be done before forking.
    set_freevr_pointers(scene, display);

    // set the function pointer for the per-screen renderers
    vrFunctionSetCallback(VRFUNC_ALL_DISPLAY, vrCallbackCreate(freevr_renderer, 1, &display));  
    vrStart();                         // fork off the rendering processes
    display->renderer_process = 0;     // this proc is the master process
    msgInfo << "FreeVR Initialized" << sendmsg;
  }
#endif

  // make sure there is a scene object.  If none yet, create default one.
  if(!scene) {
    scene = new Scene;
  }

  // No real display, create a stub display that eats commands
  if(!display) {
    display = new DisplayDevice("Default Display");
    display->resize_window(dsiz[0], dsiz[1]);
  }

  // print any useful informational messages now that the display is setup
  if (display->get_num_processes() > 1) {
    msgInfo << "Started " << display->get_num_processes() 
            << " slave rendering processes." << sendmsg;
  }

  //
  // create other global objects for the program
  //

  rocker = new DisplayRocker(&(scene->root));

  // create commandQueue before all UIObjects!
  commandQueue = new CommandQueue(); 

  pluginMgr = new PluginMgr;

  atomSelParser = new SymbolTable;
  atomSelParser_init(atomSelParser);

  pickModeList = new PickModeList(this);
  pickList = new PickList(this);

  // create material list
  materialList = new MaterialList(&scene->root);

  // create other useful graphics objects
  axes = new Axes(display, &(scene->root));
  pickList->add_pickable(axes);
  
  fps = new FPS(display, &(scene->root));
  fps->off();

  // create the list of molecules (initially empty)
  moleculeList = new MoleculeList(this, scene);

  anim = new Animation(this);
  anim->On();

  // create the list of geometry monitors (initially empty)
  geometryList = new GeometryList(this, &(scene->root));

  menulist = new NameList<VMDMenu *>;

  uiText = new UIText(this); // text user interface
  uiText->On();

  mouse = new Mouse(this); // mouse user interface
  mouse->On();

  spaceball = new Spaceball(this); // Spaceball 6DOF input device
  spaceball->On();

#ifdef WIN32
  win32joystick = new Win32Joystick(this); // Win32 Joystick devices
  win32joystick->On();
#endif

#ifdef VMDIMD
  imdMgr = new IMDMgr(this);
  imdMgr->On();
#endif

  stage = new Stage(&(scene->root));

  vmdcollab = new VMDCollab(this);
  vmdcollab->On();

  // make the classes which can render scenes to different file formats
  fileRenderList = new FileRenderList(this);

  display->queue_events(); // begin accepting UI events in graphics window

  // Create the menus; XXX currently this must be done _before_ calling
  // uiText->read_init() because otherwise the new menus created by the 
  // plugins loaded by the iit script won't be added to the main menu.
  activate_menus();
  
  // XXX loading static plugins should be controlled by a startup option
  pluginMgr->load_static_plugins();

  // plugin_update must take place _after_ creation of uiText.
  plugin_update();

  VMDupdate(VMD_IGNORE_EVENTS); // flush cmd queue, prepare to enter event loop

  // Read the initialization code for the text interpreter.
  // We wait to do it now since that script might contain commands that use 
  // the event queue
  uiText->read_init();

  // If there's no text interpreter, show the main menu
#ifndef VMDTCL
#ifndef VMDPYTHON
  menu_show("main", 1);
#endif
#endif
  
  // successful initialization.  Turn off the exit flag return success
  exitFlag = FALSE;
  return TRUE;
}

int VMDApp::num_menus() { return menulist->num(); }

int VMDApp::add_menu(VMDMenu *m) {
  if (menulist->typecode(m->get_name()) != -1) {
    msgErr << "Menu " << m->get_name() << " already exists." << sendmsg;
    return 0;  
  }
  menulist->add_name(m->get_name(), m);
  return 1;
}
 
int VMDApp::remove_menu(const char *name) {
  int id = menulist->typecode(name);
  if (id == -1) {
    msgErr << "Menu " << name << " does not exist." << sendmsg;
    return 0;  
  }
  NameList<VMDMenu *> *newmenulist = new NameList<VMDMenu *>;
  for (int i=0; i<menulist->num(); i++) {
    VMDMenu *menu = menulist->data(i);
    if (i == id) {
      delete menu;
    } else {
      newmenulist->add_name(menu->get_name(), menu);
    }
  }
  delete menulist;
  menulist = newmenulist;
  return 1;
}
 
void VMDApp::menu_add_extension(const char *shortname, const char *menu_path) {
  commandQueue->runcommand(new CmdMenuExtensionAdd(shortname,menu_path));
}

void VMDApp::menu_remove_extension(const char *shortname) {
  commandQueue->runcommand(new CmdMenuExtensionRemove(shortname));
}

const char *VMDApp::menu_name(int i) { return menulist->name(i); }

int VMDApp::menu_status(const char *name) {
  int id = menulist->typecode(name);
  if (id == -1) return 0;
  return menulist->data(id)->active();
}

int VMDApp::menu_location(const char *name, int &x, int &y) {
  int id = menulist->typecode(name);
  if (id == -1) return 0;
  menulist->data(id)->where(x, y);
  return 1;
}

int VMDApp::menu_show(const char *name, int on) {
  int id = menulist->typecode(name);
  if (id == -1) return 0;
  VMDMenu *obj = menulist->data(name);
  if (on)
    obj->On();
  else
    obj->Off();
  commandQueue->runcommand(new CmdMenuShow(name, on));
  return 1;
}

int VMDApp::menu_move(const char *name, int x, int y) {
  int id = menulist->typecode(name);
  if (id == -1) return 0;
  menulist->data(id)->move(x, y);
  return 1;
}


int VMDApp::menu_select_mol(const char *name, int molno) {
  int id = menulist->typecode(name);
  if (id == -1) return 0;
  return menulist->data(id)->selectmol(molno);
}


// redraw the screen and update all things that need updating
int VMDApp::VMDupdate(int check_for_events) {
  // clear background processing flag
  background_processing_clear();

  // see if there are any pending events; if so, get them
  if (check_for_events) {
    commandQueue->check_events();
#ifdef VMDGUI
#ifdef VMDFLTK
    // if we are using the FLTK library ...
    if(display->supports_gui()) {
#if (defined(ARCH_MACOSX) || defined(ARCH_MACOSXX86) || defined(ARCH_MACOSXX86_64)) && defined(VMDTCL)
      // don't call wait(0) since this causes Tcl/Tk to mishandle events
      Fl::flush();
#else
      Fl::wait(0);
#endif
    }
#endif
#endif
  } 
  
  // check if the user has requested to exit the program.
  if (exitFlag) 
    return FALSE;
 
  commandQueue->execute_all(); // execute commands still in the queue

  int needupdate = 0;
#if 1
  // Only prepare objects if display update is enabled
  // XXX avoid N^2 behavior when loading thousdands of molecules, 
  // don't prepare for drawing unless we have to.
  if (UpdateDisplay) {
    // If a resetview is pending, take care of it now before drawing
    if (ResetViewPending) 
      scene_resetview_newmoldata();

    needupdate = scene->prepare(); // prepare all objects for drawing
  } else {
    // XXX this has to be done currently to force trajectories to continue
    //     loading frames since they don't have their own UIObject yet.
    int molnum = moleculeList->num();
    int i;
    for (i=0; i<molnum; i++) {
      Molecule *mol = moleculeList->molecule(i);
      if (mol != NULL) {
        if (mol->get_new_frames()) {
          needupdate = 1; // need to update if any new frames were loaded
        }
      }
    }
  }
#else
  // XXX this has to be done currently to force trajectories to continue
  //     loading frames since they don't have their own UIObject yet.
  needupdate = scene->prepare(); // prepare all objects for drawing
#endif

  // turn off the spinning vmd when molecules are loaded
  if (vmdTitle && moleculeList->num() > 0) {
    delete vmdTitle;
    vmdTitle = NULL;
  }
  
  // Update the display (or sleep a tiny bit).
  if (UpdateDisplay && (needupdate || display->needRedraw())) {
    scene->draw(display);   // make the display redraw if necessary
    scene->draw_finished(); // perform any necessary post-drawing cleanup
  } else {
    // if not updating the display or doing background I/O, 
    // we sleep so we don't hog CPU.
    if (!needupdate && !background_processing())
      vmd_msleep(1); // sleep for 1 millisecond or more
  }

  // XXX A hack to decrease CPU utilization on machines that have
  //     problems keeping up with the 3-D draw rate at full speed.
  if (getenv("VMDMSECDELAYHACK") != NULL) {
    // Delay the whole program for a user-specified number of milliseconds.  
    vmd_msleep(atoi(getenv("VMDMSECDELAYHACK"))); 
  }

  return TRUE;
}


// exit the program normally; first delete all the necessary objects
void VMDApp::VMDexit(const char *exitmsg, int exitcode, int pauseseconds) {
#if defined(VMDTKCON)
  // switch to text mode and flush all pending messages to the screen.
  vmdcon_use_text();
  vmdcon_purge();
#endif

  msgInfo << VERSION_MSG << sendmsg; 
  if(exitmsg && strlen(exitmsg)) {
    msgInfo << exitmsg << sendmsg;
  } else {
    msgInfo << "Exiting normally." << sendmsg;
  }

  vmd_sleep(pauseseconds);  // sleep for requested number of seconds

  // make the VMDupdate event loop return FALSE.
  exitFlag = 1;
}

VMDApp::~VMDApp() {
  int i;

  // delete all objects we created during initialization
  if (fileRenderList) delete fileRenderList;
  if (mouse)          delete mouse;
  if (spaceball)      delete spaceball;

#ifdef WIN32
  if (win32joystick)  delete win32joystick;
#endif

  if (uivr)           delete uivr;
  if (geometryList)   delete geometryList;

#ifdef VMDIMD
  if (imdMgr)         delete imdMgr;
  imdMgr = NULL;      // prevent free mem reads at moleculeList deletion
#endif

  if (vmdTitle)       delete vmdTitle;
  if (stage)          delete stage;
  if (axes)           delete axes;
  if (fps)            delete fps;
  if (pickModeList)   delete pickModeList;
  if (materialList)   delete materialList;
  if (pluginMgr)      delete pluginMgr;
  if (cuda)           delete cuda;
  delete vmdcollab;

  // delete all of the Forms;
  if (menulist) {
    for (i=0; i<menulist->num(); i++)
      delete menulist->data(i);
    delete menulist;
  }

#ifdef VMDGUI
  // Close all GUI windows
#ifdef VMDFLTK
  if (display->supports_gui()) {
    Fl::wait(0); // Give Fltk a chance to close the menu windows.  
  }
#endif
#endif

  // Tcl/Python interpreters can only be deleted after Tk forms are shutdown
  if (uiText)         delete uiText;

  // delete the list of user keys and descriptions 
  for (i=0; i<userKeys.num(); i++)
    delete [] userKeys.data(i);

  for (i=0; i<userKeyDesc.num(); i++)
    delete [] userKeyDesc.data(i);

  delete atomSelParser;
  delete anim;

  // delete commandQueue _after_ all UIObjects have been deleted; otherwise
  // they will try to unRegister with a deleted CommandQueue.
  delete commandQueue;

  // (these dependencies really suck) delete moleculelist after uiText
  // because text interfaces might use commands that require moleculeList to
  // be there.
  delete moleculeList;

  // picklist can't be deleted until the molecule is deleted, since
  // the DrawMolecule destructor needs it.
  delete pickList;
 
  delete display;
  delete scene;
}

unsigned long VMDApp::get_repserialnum(void) {
  // first serial number returned will be 1, never return 0.
  repserialnum++;
  return repserialnum;
}

unsigned long VMDApp::get_texserialnum(void) {
  // first serial number returned will be 1, never return 0.
  texserialnum++;
  return texserialnum;
}

void VMDApp::show_stride_message() {
  if (stride_firsttime) {
    stride_firsttime = 0;
    msgInfo <<
     "In any publication of scientific results based in part or\n"
     "completely on the use of the program STRIDE, please reference:\n"
     " Frishman,D & Argos,P. (1995) Knowledge-based secondary structure\n"
     " assignment. Proteins: structure, function and genetics, 23, 566-579." 
      << "\n" << sendmsg;
  }
}

// this is a nasty hack until we get around to returning values from scripts
// properly.

#ifdef VMDTK
#include <tcl.h> 
#endif

char *VMDApp::vmd_choose_file(const char *title,
        const char *extension, 
        const char *extension_label, int do_save) {
  
 char *chooser = getenv("VMDFILECHOOSER");
 if (!chooser || !strupcmp(chooser, "TK")) {
    
#ifdef VMDTK
  JString t = title;
  JString ext = extension;
  JString label = extension_label;
  char *cmd = new char[300 + t.length() +ext.length() + label.length()];
  // no default extension for for saves/loads , because otherwise it 
  // automatically adds the file extension whether you specify it or not, and 
  // when the extension is * it won't let you save/load a file without an 
  // extension!
  if (do_save) {
    sprintf(cmd, "tk_getSaveFile -title {%s} -filetypes {{{%s} {%s}} {{All files} {*}}}", (const char *)t, (const char *)extension_label, (const char *)extension);
  } else {
    sprintf(cmd, "tk_getOpenFile -title {%s} -filetypes {{{%s} {%s}} {{All files} {*}}}", (const char *)t, (const char *)extension_label, (const char *)extension);
  }
  Tcl_Interp *interp = uiText->get_tcl_interp();
  if (interp) {
    int retval = Tcl_Eval(interp, cmd);
    delete [] cmd;
    if (retval == TCL_OK) {
      const char *result = Tcl_GetStringResult(interp);
      if (result == NULL || strlen(result) == 0) {
        return NULL;
      } else {
        return stringdup(result);
      }
    }
  }
  // fall through to next level on failure
#endif

 } 

#ifdef VMDFLTK
  return stringdup(fl_file_chooser(title, extension, NULL));
#endif

  char *result = new char[256];
  fgets(result, 256, stdin);
  return result;
}
 
// file renderer API
int VMDApp::filerender_num() {
  return fileRenderList->num();
}
const char *VMDApp::filerender_name(int n) {
  return fileRenderList->name(n); 
}
int VMDApp::filerender_valid(const char *method) {
  return (fileRenderList->find(method) != NULL);
}
int VMDApp::filerender_has_antialiasing(const char *method) {
  return (fileRenderList->has_antialiasing(method));
}
int VMDApp::filerender_aalevel(const char *method, int aalevel) {
  return fileRenderList->aalevel(method, aalevel);
}
int VMDApp::filerender_imagesize(const char *method, int *w, int *h) {
  if (!w || !h) return FALSE;
  return fileRenderList->imagesize(method, w, h); 
}
int VMDApp::filerender_has_imagesize(const char *method) {
  return fileRenderList->has_imagesize(method);
}
int VMDApp::filerender_aspectratio(const char *method, float *aspect) {
  if (!aspect) return FALSE;
  return fileRenderList->aspectratio(method, aspect);
}
int VMDApp::filerender_numformats(const char *method) {
  return fileRenderList->numformats(method);
}
const char *VMDApp::filerender_get_format(const char *method, int i) {
  return fileRenderList->format(method, i);
}
const char *VMDApp::filerender_cur_format(const char *method) {
  return fileRenderList->format(method);
}
int VMDApp::filerender_set_format(const char *m, const char *fmt) {
  return fileRenderList->set_format(m, fmt);
}

int VMDApp::filerender_render(const char *m, const char *f, const char *e) {
  int retval = fileRenderList->render(f, m, e);
  if (retval) {
    commandQueue->runcommand(new CmdRender(f, m, e));
  }
  return retval;
}
const char *VMDApp::filerender_option(const char *m, const char *o) {
  FileRenderer *ren = fileRenderList->find(m);
  if (!ren) {
    return NULL;
  }
  if (o) {
    ren->set_exec_string(o);
    commandQueue->runcommand(new CmdRenderOption(m, o));
  }
  return ren->saved_exec_string();
}

// XXX The Scene doesn't return error codes, so I don't know if the commands
// worked or not.  I do what error checking I can here and hope that it works.
int VMDApp::scene_rotate_by(float angle, char ax, float incr) {
  if (ax < 'x' || ax > 'z') return FALSE;  // failed
  rocker->stop_rocking();
  if (incr) {
    int nsteps = (int)(fabs(angle / incr) + 0.5);
    incr = (float) (angle < 0.0f ? -fabs(incr) : fabs(incr));
    rocker->start_rocking(incr, ax, nsteps, TRUE);
    commandQueue->runcommand(new CmdRotate(angle, ax, CmdRotate::BY, incr)); 
   
  } else {
    scene->root.add_rot(angle, ax);
    commandQueue->runcommand(new CmdRotate(angle, ax, CmdRotate::BY));
  }
  return TRUE;
}
int VMDApp::scene_rotate_to(float angle, char ax) {
  if (ax < 'x' || ax > 'z') return FALSE;  // failed
  rocker->stop_rocking();
  scene->root.set_rot(angle, ax);
  commandQueue->runcommand(new CmdRotate(angle, ax, CmdRotate::TO));
  return TRUE;
}
int VMDApp::scene_rotate_by(const float *m) {
  Matrix4 mat(m);
  scene->root.add_rot(mat);
  commandQueue->runcommand(new CmdRotMat(mat, CmdRotMat::BY));
  return TRUE;
}
int VMDApp::scene_rotate_to(const float *m) {
  Matrix4 mat(m);
  scene->root.set_rot(mat);
  commandQueue->runcommand(new CmdRotMat(mat, CmdRotMat::TO));
  return TRUE;
}
int VMDApp::scene_translate_by(float x, float y, float z) {
  scene->root.add_glob_trans(x, y, z);
  commandQueue->runcommand(new CmdTranslate(x,y,z,CmdTranslate::BY));
  return TRUE;
}
int VMDApp::scene_translate_to(float x, float y, float z) {
  scene->root.set_glob_trans(x, y, z);
  commandQueue->runcommand(new CmdTranslate(x,y,z,CmdTranslate::TO));
  return TRUE;
}
int VMDApp::scene_scale_by(float s) {
  if (s <= 0) return FALSE; 
  scene->root.mult_scale(s);
  commandQueue->runcommand(new CmdScale(s, CmdScale::BY));
  return TRUE;
}
int VMDApp::scene_scale_to(float s) {
  if (s <= 0) return FALSE; 
  scene->root.set_scale(s);
  commandQueue->runcommand(new CmdScale(s, CmdScale::TO));
  return TRUE;
}
void VMDApp::scene_resetview_newmoldata() {
#if 1
  // XXX avoid N^2 behavior when loading thousands of molecules
  // we should only be resetting the view when necessary
  if (UpdateDisplay) {
    int nodisrupt = 0;

    if (getenv("VMDNODISRUPTHACK"))
      nodisrupt=1;

    if (nodisrupt && (moleculeList->num() > 1)) {
      moleculeList->center_top_molecule(); // new/top mol inherits current view
    } else {
      scene_resetview(); // reset all molecules to the newly loaded structure
    }
    ResetViewPending = FALSE;
  } else {
    ResetViewPending = TRUE;
  }
#else
  scene_resetview(); // reset all molecules to the newly loaded structure
#endif
}
void VMDApp::scene_resetview() {
  scene->root.reset_transformation();
  // center the view based on the displayed representations
  moleculeList->center_from_top_molecule_reps();
  moleculeList->center_all_molecules();
  commandQueue->runcommand(new CmdResetView);
}
int VMDApp::scene_rock(char ax, float step, int nsteps) {
  if (ax < 'x' || ax > 'z') return FALSE;  // failed
  rocker->start_rocking(step, ax, nsteps);
  commandQueue->runcommand(new CmdRockOn(step, ax, nsteps));
  return TRUE;
}
int VMDApp::scene_rockoff() {
  rocker->stop_rocking();
  commandQueue->runcommand(new CmdRockOff);
  return TRUE;
} 
int VMDApp::scene_stoprotation() {
  rocker->stop_rocking();
  mouse->stop_rotation();
  return TRUE;
}

int VMDApp::animation_num_dirs() {
  return Animation::ANIM_TOTAL_DIRS;
}

const char *VMDApp::animation_dir_name(int i) {
  if (i < 0 || i >= Animation::ANIM_TOTAL_DIRS) return NULL;
  return animationDirName[i]; 
}
   
int VMDApp::animation_set_dir(int d) {
  Animation::AnimDir dir = (Animation::AnimDir)d;
  anim->anim_dir(dir);
  commandQueue->runcommand(new CmdAnimDir(dir));
  return 1;
}

int VMDApp::animation_num_styles() {
  return Animation::ANIM_TOTAL_STYLES;
}

const char *VMDApp::animation_style_name(int i) {
  if (i < 0 || i >= Animation::ANIM_TOTAL_STYLES) return NULL;
  return animationStyleName[i];
}

int VMDApp::animation_set_style(int s) {
  Animation::AnimStyle style = (Animation::AnimStyle)s;
  anim->anim_style(style);
  commandQueue->runcommand(new CmdAnimStyle(style));
  return 1;
}

int VMDApp::animation_set_frame(int frame) {
    anim->goto_frame(frame);
    anim->anim_dir(Animation::ANIM_PAUSE);
    commandQueue->runcommand(new CmdAnimJump(frame));
    return 1;
}

int VMDApp::animation_set_stride(int stride) {
    anim->skip(stride);
    commandQueue->runcommand(new CmdAnimSkip(stride));
    return 1;
}

int VMDApp::animation_set_speed(float speed) {
    anim->speed(speed);
    commandQueue->runcommand(new CmdAnimSpeed(speed));
    return 1;
}

const char *VMDApp::filerender_default_option(const char *m) {
  FileRenderer *ren = fileRenderList->find(m);
  if (!ren) {
    return NULL;
  }
  return ren->default_exec_string();
}
const char *VMDApp::filerender_default_filename(const char *m) {
  FileRenderer *ren = fileRenderList->find(m);
  if (!ren) {
    return NULL;
  }
  return ren->default_filename();
}
 

// plugin stuff 

vmdplugin_t *VMDApp::get_plugin(const char *type, const char *name) {
  if (!pluginMgr) return NULL;
  if (!type || !name) return NULL;
  PluginList p;
  vmdplugin_t *plugin = NULL;
  if (pluginMgr->plugins(p, type, name)) {
    plugin = p[0];

    // loop over plugins and select the highest version number for a 
    // given plugin type/name combo.
    for (int i=1; i<p.num(); i++) {
      vmdplugin_t *curplugin = p[i];
      if (curplugin->majorv > plugin->majorv || 
          (curplugin->majorv == plugin->majorv && curplugin->minorv > plugin->minorv))
        plugin = curplugin;
    }
  } 
  return plugin;
}

int VMDApp::list_plugins(PluginList &p, const char *type) {
  if (!pluginMgr) return 0;
  return pluginMgr->plugins(p, type);
}

int VMDApp::plugin_dlopen(const char *filename) {
  if (!pluginMgr) {
    msgErr << "scan_plugins: no plugin manager available" << sendmsg;
    return -1;
  }
  if (!filename) return -1;
  return pluginMgr->load_sharedlibrary_plugins(filename);
}

void VMDApp::plugin_update() {
  commandQueue->runcommand(new CmdPluginUpdate);
}

void VMDApp::display_update_on(int ison) {
  UpdateDisplay = ison;
}

int VMDApp::display_update_status() {
  return (UpdateDisplay != 0);
}

void VMDApp::display_update() {
  int prevUpdateFlag = UpdateDisplay;
  UpdateDisplay = 1;
  VMDupdate(VMD_IGNORE_EVENTS);
  UpdateDisplay = prevUpdateFlag;
}

void VMDApp::display_update_ui() {
  VMDupdate(VMD_CHECK_EVENTS);
}

int VMDApp::num_color_categories() {
  return scene->num_categories();
}
const char *VMDApp::color_category(int n) {
  return scene->category_name(n);
}

int VMDApp::color_add_item(const char *cat, const char *name, const char *defcolor) {
  int init_color = scene->color_index(defcolor);
  if (init_color < 0) {
    msgErr << "Cannot add color item: invalid color name '" << defcolor << "'" << sendmsg;
    return FALSE;
  }
  int ind = scene->category_index(cat);
  if (ind < 0) {
    ind = scene->add_color_category(cat);
  }
  if (scene->add_color_item(ind, name, init_color) < 0) {
    return FALSE;
  }
  commandQueue->runcommand(new CmdColorItem(cat, name, defcolor));
  return TRUE;
}

int VMDApp::num_color_category_items(const char *category) {
  int colCatIndex = scene->category_index(category);
  if (colCatIndex < 0) return 0;
  return scene->num_category_items(colCatIndex);
}
const char *VMDApp::color_category_item(const char *category, int n) {
  int colCatIndex = scene->category_index(category);
  if (colCatIndex < 0) return 0;
  return scene->category_item_name(colCatIndex, n); // XXX check valid n
}
int VMDApp::num_colors() {
  return MAXCOLORS;
}
int VMDApp::num_regular_colors() {
  return REGCLRS;
}
const char *VMDApp::color_name(int n) {
  return scene->color_name(n);
}
int VMDApp::color_index(const char *color) {
  if (!color) return -1;
  // If it's a number in the valid range, return the number; otherwise return
  // -1.
  int i;
  if (sscanf(color, "%d", &i)) {
    if (i >= 0 && i < MAXCOLORS)
      return i;
    else
      return -1;
  }
  // look up the color by name.
  return scene->color_index(color);
} 
int VMDApp::color_value(const char *colorname, float *r, float *g, float *b) {
  int colIndex = color_index(colorname);
  if (colIndex < 0) return 0;
  const float *col = scene->color_value(colIndex);
  *r = col[0];
  *g = col[1];
  *b = col[2];
  return 1;
}
int VMDApp::color_default_value(const char *colorname, float *r, float *g, float *b) {
  int colIndex = color_index(colorname);
  if (colIndex < 0) return 0;
  const float *col = scene->color_default_value(colIndex);
  *r = col[0];
  *g = col[1];
  *b = col[2];
  return 1;
}
const char *VMDApp::color_mapping(const char *category, const char *item) {
  
  int colCatIndex = scene->category_index(category);
  if (colCatIndex < 0) return 0;

  int colNameIndex = scene->category_item_index(colCatIndex, item);
  if (colNameIndex < 0) return 0;
  
  int ind = scene->category_item_value(colCatIndex, colNameIndex);
  return scene->color_name(ind);
}

const char *VMDApp::color_get_restype(const char *resname) {
  int id = moleculeList->resTypes.typecode(resname);
  if (id < 0) return NULL;
  return moleculeList->resTypes.data(id);
}

int VMDApp::color_set_restype(const char *resname, const char *restype) {
  int cat = moleculeList->colorCatIndex[MLCAT_RESTYPES];
  int ind = scene->category_item_index(cat, restype);
  if (ind < 0) return FALSE;  // nonexistent restype category

  // Use the string stored in Scene rather than the one passed to this
  // function, since then we don't have to worry about copying it and
  // freeing it later.
  const char *stable_restype_name = scene->category_item_name(cat, ind);

  // if the resname doesn't have an entry yet, create one.
  int resname_id = moleculeList->resTypes.add_name(resname, restype);
  moleculeList->resTypes.set_data(resname_id, stable_restype_name);
  scene->root.color_changed(cat);
  return TRUE;
}

int VMDApp::colorscale_info(float *mid, float *min, float *max) {
  scene->colorscale_value(mid, min, max);
  return 1;
}
int VMDApp::num_colorscale_methods() {
  return scene->num_colorscale_methods();
}
int VMDApp::colorscale_method_current() {
  return scene->colorscale_method();
}
const char *VMDApp::colorscale_method_name(int n) {
  if (n < 0 || n >= scene->num_colorscale_methods()) return NULL;
  return scene->colorscale_method_name(n);
}
int VMDApp::colorscale_method_index(const char *method) {
  for (int i=0; i<scene->num_colorscale_methods(); i++) {
    if (!strupncmp(method, scene->colorscale_method_name(i),CMDLEN)) {
      return i;
    }
  }
  return -1;
}  

int VMDApp::get_colorscale_colors(int whichScale, 
      float min[3], float mid[3], float max[3]) {
  return scene->get_colorscale_colors(whichScale, min, mid, max);
}

int VMDApp::set_colorscale_colors(int whichScale, 
      const float min[3], const float mid[3], const float max[3]) {
  if (scene->set_colorscale_colors(whichScale, min, mid, max)) {
    commandQueue->runcommand(new CmdColorScaleColors(
          scene->colorscale_method_name(whichScale), mid, min, max));
    return TRUE;
  }
  return FALSE;
}

int VMDApp::color_changename(const char *category, const char *colorname, 
                     const char *color) {

  if (!category || !colorname || !color) return 0;

  int colCatIndex = scene->category_index(category);
  if (colCatIndex < 0) return 0;
  
  int colNameIndex = scene->category_item_index(colCatIndex, colorname);
  if (colNameIndex < 0) return 0;

  int newIndex = color_index(color);
  if (newIndex < 0) return 0;
 
  // all systems go...
  scene->set_category_item(colCatIndex, colNameIndex, newIndex);
  
  // tell the rest of the world
  commandQueue->runcommand(new CmdColorName(category, colorname, color));
  return 1;
}

int VMDApp::color_get_from_name(const char *category, const char *colorname, 
                     const char **color) {

  if (!category || !colorname) return 0;

  int colCatIndex = scene->category_index(category);
  if (colCatIndex < 0) return 0;
  
  int colNameIndex = scene->category_item_index(colCatIndex, colorname);
  if (colNameIndex < 0) return 0;
 
  // all systems go...
  int colIndex = scene->get_category_item(colCatIndex, colNameIndex);
  if (colIndex < 0) return 0;
  
  *color = color_name(colIndex);
      
  return 1;
}


int VMDApp::color_changevalue(const char *color, float r, float g, float b) {
  int ind = color_index(color);
  if (ind < 0) return 0;
  float rgb[3] = {r, g, b};
  scene->set_color_value(ind, rgb);
  commandQueue->runcommand(new CmdColorChange(color, r, g, b));
  return 1;
}
  
int VMDApp::colorscale_setvalues(float mid, float min, float max) {
  scene->set_colorscale_value(min, mid, max);
  commandQueue->runcommand(new CmdColorScaleSettings(mid, min, max));
  return 1;
}

int VMDApp::colorscale_setmethod(int method) {
  if (method < 0 || method >= scene->num_colorscale_methods()) return 0;
  scene->set_colorscale_method(method);
  commandQueue->runcommand(new CmdColorScaleMethod(
        scene->colorscale_method_name(method)));
  return 1;
}
  
  
int VMDApp::logfile_read(const char *path) {
  uiText->read_from_file(path);
  return 1;
}

int VMDApp::save_state() {
  char *file = vmd_choose_file(
    "Enter filename to save current VMD state:",  // Title
    "*.vmd",                                      // extension
    "VMD files",                                  // label
    1                                             // do_save
  );
  if (!file)
    return 1;
  int retval = uiText->save_state(file);
  delete [] file;
  return retval;
}
 
int VMDApp::num_molecules() {
  return moleculeList->num();
}

int VMDApp::molecule_new(const char *name) {
  Molecule *newmol = new Molecule(name, this, &(scene->root));
  moleculeList->add_molecule(newmol);
  int molid = newmol->id();
  commandQueue->runcommand(new