src/aclvis/Interact.cpp

Go to the documentation of this file.

// -*- C++ -*-
/***************************************************************************
 *
 * The IPPL Framework
 * 
 * This program was prepared by PSI. 
 * All rights in the program are reserved by PSI.
 * Neither PSI nor the author(s)
 * makes any warranty, express or implied, or assumes any liability or
 * responsibility for the use of this software
 *
 * Visit http://www.acl.lanl.gov/POOMS for more details
 *
 ***************************************************************************/

// -*- C++ -*-
/***************************************************************************
 *
 * The IPPL Framework
 * 
 *
 * Visit http://people.web.psi.ch/adelmann/ for more details
 *
 ***************************************************************************/

#include "aclvis/Interact.h"
#include "aclvis/aclvis.h"
#include "aclvis/MainWindow.h"
#include "aclvis/UIWindow.h"
#include "Profile/Profiler.h"

#ifdef IPPL_USE_STANDARD_HEADERS
#include <iostream>
using namespace std;
#else
#include <iostream.h>
#endif

#include <vtk.h>
#include <vtkXRenderWindow.h>

extern MainWindow *mainWindow;

VizTool *current_viztool;

VizRecord::VizRecord() {
  TAU_PROFILE("VizRecord::VizRecord()", "void ()", TAU_VIZ);

  caller = NULL;
  strcpy(name,"");
  id = 0;
  tool = NULL;
  tooltype = Empty;
}  

void 
VizRecord::Print() {
  TAU_PROFILE("VizRecord::Print()", "void ()", TAU_VIZ | TAU_IO);

    cerr << "Caller: " << caller << "\n";
    cerr << "Name: " << name << "\n";
    cerr << "Id: " << id << "\n";
    cerr << "Tool: " << tool << "\n";
    cerr << "ToolType: " << tooltype << "\n\n";
}

int 
VizCollection::MatchTest(VizRecord *current, VizRecord *data) {
  TAU_PROFILE("VizCollection::MatchTest()", "int (VizRecord *, VizRecord *)", TAU_VIZ);

  Boolean flag;

  flag = 1;
  //current->Print();
  if (data->caller != NULL) {
    flag = flag && (current->caller == data->caller);
  }
  if (strcmp(data->name,"") != 0) {
    flag = flag && (strcmp(current->name, data->name) == 0);
  }
  if (data->tool != NULL) {
    flag = flag && (current->tool == data->tool);
  }
  if (data->id != 0) {
    flag = flag && (current->id == data->id);
  }
  if (data->tooltype != Empty) {
    flag = flag && (current->tooltype == data->tooltype);
  }
  return flag;
}

VizRecord*
VizCollection::FindItem(VizRecord *data) {
  TAU_PROFILE("VizCollection::FindItem()", "VizRecord * (VizRecord *)", TAU_VIZ);

  VizRecord *current;

  //  cerr << "Match Record: \n";
  //  data->Print();
  this->InitTraversal();
  // cerr << "Searching: \n";
  while ((current = (VizRecord *)this->GetNextItemAsObject()) != NULL) {
    //current->Print();
    if (MatchTest(current,data) == 1) {
      //cerr << "Match Found: \n";
      //current->Print();
      return current;
    }
  }  
  //  cerr << "No Match Found -- Return NULL \n";
  return NULL;
}

VizRecord*
VizCollection::FindNextItem(VizRecord *data) {
  TAU_PROFILE("VizCollection::FindNextItem()", "VizRecord * (VizRecord *)", TAU_VIZ);

  VizRecord *current;

  //cerr << "Searching: \n";
  while ((current = (VizRecord *)this->GetNextItemAsObject()) != NULL) {
    if (MatchTest(current,data) == 1) {
      //cerr << "Match Found: \n";
      //current->Print();
      return current;
    }
  }  
  //   cerr << "No Match Found -- Return NULL \n";
  return NULL;
}


extern vtkXRenderWindow *renWin;
extern vtkRenderer *ren1;

VizTool::VizTool() : interpreter("vizard> ")
{
  TAU_PROFILE("VizTool::VizTool()", "void ()", TAU_VIZ);
  // X window variables
  // int argc; 
  // char *argv[1];
  // int i;
  RenderTool *rendertool;
  VizRecord *viz_data;
  
  image_file_base = 0;
  image_file_ext = 0;
  image_next_num = 0;

  InitToolIds();

  rendertool = new RenderTool;
  rendertool->SetRenderWindow(renWin);
  rendertool->SetRenderer(ren1);
  SetSelectedTool(Render, rendertool);

  viz_db = new VizCollection();

  viz_data = new VizRecord();
  viz_data->caller = rendertool;
  strcpy(viz_data->name, "Render Tool");
  viz_data->tool = rendertool;
  viz_data->id = GetUniqueToolId(Render);
  viz_data->tooltype = Render;

  viz_db->AddItem(viz_data);

  current_viztool = this;

  interactIter = 0;
  goFlag       = 0;
  InteractFlag = 1;

  // set up commands for the interpreter
  toolcmd = new InterpCmdTool(this);
  interpreter.addCommand(*toolcmd);
}

void
VizTool::InterpretCommand(const char *str) {
  TAU_PROFILE("VizTool::InterpretCommand()", "void", TAU_VIZ);
  interpreter.evalCommand(str);
}

void
VizTool::InterpretInteract(int timeoutseconds) {
  TAU_PROFILE("VizTool::InterpretInteract()", "void", TAU_VIZ);
  interpreter.interact(timeoutseconds);
}

VizCollection* 
VizTool::GetVizDB() {
  TAU_PROFILE("VizTool::GetVizDB()", "VizCollection * ()", TAU_VIZ);
  return viz_db;
}

int 
VizTool::GetUniqueToolId(ToolType tooltype) {
  TAU_PROFILE("VizTool::GetUniqueToolId()", "int (ToolType)", TAU_VIZ);
  ToolId[tooltype]++;
  return ToolId[tooltype];
};

void 
VizTool::InitToolIds() {
  TAU_PROFILE("VizTool::InitToolIds()", "void ()", TAU_VIZ);
  int i;
  for (i = 0; i < NUM_OF_TOOL_TYPES; i++) {
    ToolId[i]=0;
  }
};

void 
VizTool::SetSelectedTool(ToolType tooltype, Tool *tool) {
  TAU_PROFILE("VizTool::SetSelectedTool()", "void (ToolType, Tool *)", TAU_VIZ);
  SelectedTool[tooltype] = tool;
};

Tool*
VizTool::GetSelectedTool(ToolType tooltype) {
  TAU_PROFILE("VizTool::GetSelectedTool()", "Tool * (ToolType)", TAU_VIZ);
  return SelectedTool[tooltype];
};

void 
VizTool::Interact(int flag) {
  TAU_PROFILE("VizTool::Interact()", "void (int)", TAU_VIZ);

  /* There is nothing special about XtAppMainLoop; it is
     simply an infinite loop that calls XtAppNextEvent and then
     XtDispatchEvent. */
  //  XtAppMainLoop(app);

  XEvent event_return;
  Boolean test;
  // XtAppContext myapp;

  RenderTool *rendertool;

  current_viztool = this;

  rendertool = (RenderTool *)current_viztool->GetSelectedTool(Render);
  rendertool->GetRenderWindow()->Render();

  // write out an image, if necessary
  char imagefile[4096];
  if (GetImageName(imagefile)) {
    cerr << "VizTool: writing image to file '" << imagefile << "'." << endl;
    rendertool->GetRenderWindow()->SetFilename(imagefile);
    rendertool->GetRenderWindow()->SaveImageAsPPM();
    image_next_num++;
  }

  if (goFlag == 0) { 
    InteractFlag = 1; // added by bfh
    while (InteractFlag == 1) {
      XtAppNextEvent(UIWindow::getAppContext(), &event_return); 
      test = XtDispatchEvent(&event_return); 
    }
  } else {
    while (XtAppPending(UIWindow::getAppContext())) { 
      XtAppNextEvent(UIWindow::getAppContext(), &event_return); 
      test = XtDispatchEvent(&event_return);
      if (test);                // only here to eliminate warning
    } 
  }
  interactIter++;
}

void 
VizTool::InteractExit() {
  TAU_PROFILE("VizTool::InteractExit()", "void ()", TAU_VIZ);
  //cerr << "Interact Exit \n";
  InteractFlag = 0;
}

void 
VizTool::InteractStopFlow() {
  TAU_PROFILE("VizTool::InteractExit()", "void ()", TAU_VIZ);
  //cerr << "Interact StopFlow \n";
  goFlag = 0;
}

void 
VizTool::InteractGoFlow() {
  TAU_PROFILE("VizTool::InteractExit()", "void ()", TAU_VIZ);
  //cerr << "Interact GoFlow \n";
  goFlag = 1;
}

void 
VizTool::connect(void *caller, char *value, void *tool, ConnectDataType ctype) {
  TAU_PROFILE("VizTool::connect()", "void (void *, char *, void *, ConnectDataType)", 
    TAU_VIZ);
  //  cerr << "connect \n";

  VizRecord *viz_record;

  viz_record = new VizRecord();

  if (ctype == FieldDataType) {
    viz_record->tool = (ReadFieldTool *)tool;
    viz_record->tooltype = ReadField;
  } else {
    viz_record->tool = (ReadParticleTool *)tool;
    //    ReadParticleTool *rpt = (ReadParticleTool *)tool;
    //    rpt->DebugOn();
    viz_record->tooltype = ReadParticle;
  }
  viz_record->caller = caller;
  strcpy(viz_record->name, value);
  viz_record->id = GetUniqueToolId(viz_record->tooltype);
  viz_db->AddItem(viz_record);
  mainWindow->AddDataItem(value);
}

void VizTool::disconnect(void *caller) {
  TAU_PROFILE("VizTool::disconnect()", "void (void *)", TAU_VIZ);
  //  cerr << "disconnect \n";
  VizRecord *find, *data;

  find = new VizRecord();
  find->caller = caller;
  data = viz_db->FindItem(find);
  viz_db->RemoveItem(data);
  mainWindow->DeleteDataItem(data->name);
  delete find;
}

void 
VizTool::update(void *caller) {
  TAU_PROFILE("VizTool::update()", "void (void *)", TAU_VIZ);
  //  cerr << "VizTool::update begins\n";
  VizRecord *find, *data;

  find = new VizRecord();
  find->caller = caller;
  data = viz_db->FindItem(find);
  delete find;

  //  data->Print();

  if (data->tooltype == ReadField) {
    ReadFieldTool *readFieldTool;

    readFieldTool = (ReadFieldTool *)data->tool;
    readFieldTool->Update();    
  } else {
    ReadParticleTool *readParticleTool;

    readParticleTool = (ReadParticleTool *)data->tool;
    readParticleTool->Update();    
  }
  mainWindow->UpdateTools(caller);
  //  cerr << "VizTool::update ends" << "\n";
}


void VizTool::SetImageFileBase(const char *nm) {
  if (image_file_base != 0)
    delete [] image_file_base;
  if (nm == 0) {
    image_file_base = 0;
  } else {
    image_file_base = new char[strlen(nm) + 1];
    strcpy(image_file_base, nm);
  }
}


void VizTool::SetImageFileExt(const char *nm) {
  if (image_file_ext != 0)
    delete [] image_file_ext;
  if (nm == 0) {
    image_file_ext = 0;
  } else {
    image_file_ext = new char[strlen(nm) + 1];
    strcpy(image_file_ext, nm);
  }
}


void VizTool::SetImageNextNum(unsigned int n) { image_next_num = n; }


bool VizTool::GetImageName(char *namebuf) {
  //  if (image_file_base == 0 || image_file_ext == 0)
  if (image_file_base == 0)
    return false;
  //  sprintf(namebuf, "%s.%06d.%s",
  //      image_file_base, image_next_num, image_file_ext);
  strcpy(namebuf, image_file_base);
  return true;
}


/***************************************************************************
 * $RCSfile: Interact.cpp,v $   $Author: adelmann $
 * $Revision: 1.1.1.1 $   $Date: 2003/01/23 07:40:34 $
 * IPPL_VERSION_ID: $Id: Interact.cpp,v 1.1.1.1 2003/01/23 07:40:34 adelmann Exp $ 
 ***************************************************************************/

---