---

sxy_graph.cpp

Go to the documentation of this file.

// =======================================================================

char *graph_cpp = "$Id: sxy_graph.cpp,v 1.8 2003/04/25 20:21:43 clinio Exp $";

// =======================================================================

#include <float.h>
#include <stdlib.h>

extern "C" {
#include <iup.h>
#include <cd.h>
#include <cdiup.h>
#include <cdps.h>
#ifdef WIN32
#include <cdprint.h>
#include <cdclipbd.h>
#endif
}

#include "sxy_graph.h"
#include "sxy_task.h"
#include "sxy_chart.h"
#include "sxy_axis.h"
#include "sxy_utils.h"

// =======================================================================

#define GRAPH_ATTR_NAME "GRAPH_POINTER"
#define MAX_CHARTS  10
#define MAX_TASKS   64

// =======================================================================

// .......................................................................

SXYGraph::SXYGraph(Ihandle* iupcnv) : iup_canvas(iupcnv) {

  /* instrumentação de validação do canvas IUP */
  assert(iupcnv);
  IupMap(IupGetDialog(iupcnv));

  /* inicialização dos vetores */
  charts_vector = new SXYVector<SXYChart*>(MAX_CHARTS, NULL);
  tasks_vector = new SXYVector<SXYTask*>(MAX_TASKS, NULL);

  /* criação do canvas CD utilizando o driver IUP (com instarumentação) */
  cd_canvas = cdCreateCanvas(CD_IUP, iup_canvas);
  assert(cd_canvas);

  /* override das callbacks no IUP/Lua para métodos estáticos
   * da classe que fazem o repasse para métidos do objeto. */
  IupSetAttribute(iup_canvas, IUP_ACTION, "iupActionCallback");
  IupSetAttribute(iup_canvas, IUP_BUTTON_CB, "iupButtonCallback");
  IupSetAttribute(iup_canvas, IUP_MOTION_CB, "iupMotionCallback");
  IupSetAttribute(iup_canvas, IUP_RESIZE_CB, "iupResizeCallback");
  IupSetAttribute(iup_canvas, IUP_ENTERWINDOW_CB , "iupEnterCallback");
  IupSetAttribute(iup_canvas, IUP_LEAVEWINDOW_CB , "iupLeaveCallback");

  IupSetFunction("iupActionCallback", (Icallback)SXYGraph::iupActionCallback);
  IupSetFunction("iupButtonCallback", (Icallback)SXYGraph::iupButtonCallback);
  IupSetFunction("iupMotionCallback", (Icallback)SXYGraph::iupMotionCallback);
  IupSetFunction("iupResizeCallback", (Icallback)SXYGraph::iupResizeCallback);
  IupSetFunction("iupEnterCallback", (Icallback)SXYGraph::iupEnterCallback);
  IupSetFunction("iupLeaveCallback", (Icallback)SXYGraph::iupLeaveCallback);

  /* armazenamento do this como atributo do canvas IUP. Este atributo
   * será consultado para o repasse para o método do objeto 
   * (callbacks) */
  IupSetAttribute(iup_canvas, GRAPH_ATTR_NAME, (char*)this);
}

// .......................................................................

SXYGraph::~SXYGraph() {
  /* liberação dos vetores */
  if (charts_vector) delete charts_vector;
  charts_vector = NULL;

  if (tasks_vector) delete tasks_vector;
  tasks_vector = NULL;

   /* finalização do canvas CD */
  cdKillCanvas(cd_canvas);
  cd_canvas = NULL;
}

// .......................................................................

cdCanvas* SXYGraph::getCdCanvas(void) {
   return cd_canvas;
}

// .......................................................................

Ihandle* SXYGraph::getIupCanvas(void) {
   return iup_canvas;
}

// .......................................................................

int SXYGraph::getDeviceSizeMM(double& w, double& h) {
  double ww, hh;
  cdCanvas* cd = getCdCanvas();
  assert(cd);
  if (cdActivate(cd) == CD_ERROR) return 0;
  cdGetCanvasSize( NULL, NULL, &ww, &hh );
  w = ww; h = hh;
  return 1;
}

// .......................................................................

void SXYGraph::fitAllAxis(SXYAxisOrientation orientation) {
  int ncharts = getNumCharts();
  double min = FLT_MAX, max = -FLT_MAX;
  int i;

  for (i = 0; i < ncharts; i++) {
    SXYChart* cht = getChart(i);
    if (cht) {
      int nxaxes = cht->getNumAxes(orientation);
      for (int j = 0; j < nxaxes; j++) 
      {
        SXYAxis* ax = cht->getAxis(orientation, j);
        double tmin, tmax;
        ax->getScales(tmin, tmax);
        if (tmin < min) min = tmin;
        if (tmax > max) max = tmax;
      }
    }
  }

  SXYUtil::calcZoomOut(min, max);

  for (i = 0; i < ncharts; i++) {
    SXYChart* cht = getChart(i);
    if (cht) cht->setAllAxis(orientation, min, max);
  }
}

// .......................................................................

void SXYGraph::fitScales(SXYGraphFitOption opt) {
  /* Após o switch, faz-se um loop de fit em todos os charts XY.
   * Os eixos dos charts devem pelo suportar todas as curvas 
   * no fit. */
  switch(opt) {
    case ALL_X: {
      int ncharts = getNumCharts();
      for (int i = 0; i < ncharts; i++) {
         SXYChart* cht = getChart(i);
         if (cht) cht->fitScale(HORIZONTAL_AXIS);
      }
      fitAllAxis(HORIZONTAL_AXIS);
      break;
    }
    case ALL_Y: {
      int ncharts = getNumCharts();
      for (int i = 0; i < ncharts; i++) {
         SXYChart* cht = getChart(i);
         if (cht) cht->fitScale(VERTICAL_AXIS);
      }
      fitAllAxis(VERTICAL_AXIS);
      break;
    }
    case INDIVIDUAL_X: {
      int ncharts = getNumCharts();
      for (int i = 0; i < ncharts; i++) {
         SXYChart* cht = getChart(i);
         if (cht) cht->fitScale(HORIZONTAL_AXIS);
      }
      break;
    }
    case INDIVIDUAL_Y: {
      int ncharts = getNumCharts();
      for (int i = 0; i < ncharts; i++) {
         SXYChart* cht = getChart(i);
         if (cht) cht->fitScale(VERTICAL_AXIS);
      }
      break;
    }
  }
}

// .......................................................................

void SXYGraph::setZoom(double xratio, double yratio) {
  /* loop de zoom sobre todos os charts XY */
  int ncharts = getNumCharts();
  for (int i = 0; i < ncharts; i++) {
     SXYChart* cht = getChart(i);
     if (cht) cht->setZoom(xratio, yratio);
  }
}

// .......................................................................

void SXYGraph::drawChartsAt(cdCanvas* cnv, SXYGraphDoubleBufferMode mode) {
  /* segurança e instrumentação */
  assert(cnv != NULL);

  /* teste para ativação do canvas CD */
  if (cdActivate(cnv) == CD_ERROR) {
     IupMessage( "Erro interno", "Falha de desenho do gráfico!" );
     return;
  }

  /* loop de redesenho de todos os charts XY */
  int ncharts = getNumCharts();
  for (int i = 0; i < ncharts; i++) {
     SXYChart* cht = getChart(i);
     if (cht) cht->repaintChart(cnv, mode);
  }

  /* ativação do canvas CD que se refere ao display */
  activateDisplayCanvas();
}

// .......................................................................

void SXYGraph::redrawGraph(void) {
  assert(cd_canvas);
  drawChartsAt(cd_canvas, WITH_DOUBLE_BUFFER);
  cdFlush();
}

// .......................................................................

void SXYGraph::copyGraph(int width, int height) {
#ifdef WIN32
  cdCanvas* clipboard_canvas = NULL;
  static char buffer[64];
  sprintf(buffer, "%dx%d", width, height);
  clipboard_canvas = cdCreateCanvas(CD_CLIPBOARD, buffer);
  if (clipboard_canvas == NULL) {
     fprintf( stderr, "No clipboard_canvas created for copyGraph()\n");
     return; 
  }
  drawChartsAt(clipboard_canvas, WITHOUT_DOUBLE_BUFFER);
  cdKillCanvas(clipboard_canvas);
#endif
  redrawGraph();
}

// .......................................................................

void SXYGraph::printGraph(int ask, char* ps_cmd) {
  cdCanvas* printer_canvas = NULL;
#ifdef WIN32
  ps_cmd = NULL;
  if ( ask ) printer_canvas = cdCreateCanvas( CD_PRINTER, "SXY -d" );
  else       printer_canvas = cdCreateCanvas( CD_PRINTER, "SXY" );

#else
  static char buffer[128];
  char* filename = tempnam( "/tmp/", "sxy_ps" );
  sprintf( buffer, "%s -o -pCD_A4" , filename);
  printer_canvas = cdCreateCanvas( CD_PS, buffer );
#endif
  
  // O usuário pode ter cancelado a operação
  if (printer_canvas == NULL) {
     fprintf( stderr, "No printer_canvas created for printGraph()\n");
     return; 
  }
  drawChartsAt(printer_canvas, WITHOUT_DOUBLE_BUFFER);
  cdKillCanvas(printer_canvas);

#ifdef WIN32
#else
  if (ps_cmd != NULL) 
  { sprintf(buffer, ps_cmd, filename);
    system(buffer);
  }
#endif
  redrawGraph();
}

// .......................................................................

SXYTask* SXYGraph::getTask(int i) {
   assert(tasks_vector != NULL);
   return tasks_vector->getElement(i);
}

// .......................................................................

int SXYGraph::getNumTasks(void) {
   if (tasks_vector == NULL) return 0;
   return tasks_vector->getLength();
}

// .......................................................................

void SXYGraph::insertTask(SXYTask* tsk) {
   assert(tasks_vector != NULL);
   tasks_vector->insertElement(tsk);
}

// .......................................................................

void SXYGraph::removeTask(SXYTask* tsk) {
   assert(tasks_vector != NULL);
   tasks_vector->removeElement(tsk);
}

// .......................................................................

SXYChart* SXYGraph::getChart(int i) {
   assert(charts_vector != NULL);
   return charts_vector->getElement(i);
}

// .......................................................................

int SXYGraph::getNumCharts(void) {
   if (charts_vector == NULL) return 0;
   return charts_vector->getLength();
}

// .......................................................................

void SXYGraph::insertChart(SXYChart* cht) {
   assert(charts_vector != NULL);
   charts_vector->insertElement(cht);
}

// .......................................................................

void SXYGraph::removeChart(SXYChart* cht) {
   assert(charts_vector != NULL);
   charts_vector->removeElement(cht);
}

// .......................................................................

void SXYGraph::setStandartTasks(void) {
   this->insertTask(SXYTask::DEFAULT_MOVE_POINT_TASK);
   this->insertTask(SXYTask::DEFAULT_MOVE_LEGEND_TASK);
   this->insertTask(SXYTask::DEFAULT_ZOOM_IN_TASK);
   this->insertTask(SXYTask::DEFAULT_ADJUST_AXIS_TASK);
   this->insertTask(SXYTask::DEFAULT_EDIT_TEXT_TASK);
   this->insertTask(SXYTask::DEFAULT_CHANGE_COLORS_TASK);
}

// .......................................................................

void SXYGraph::tryGridAdjust() {
  int n = getNumCharts();
  while(--n >= 0) {
     SXYChart* cht = getChart(n);
     assert(cht != NULL);
     cht->tryGridAdjust();
  }
}

// -----------------------------------------------------------------------
// -----------------------------------------------------------------------
// -----------------------------------------------------------------------

// .......................................................................

int SXYGraph::getChartOfEvent(int x, int y) {
  activateDisplayCanvas();
  // cdCanvas2Raster( &x, &y );
  // int cxsize, cysize;
  // cdGetCanvasSize( &cxsize, &cysize, NULL, NULL );
  int ncharts = getNumCharts();
  for (int c = 0; c < ncharts; c++) {
    SXYChart* cht = getChart(c);
    XYCartesian* xycart = cht->getXyGraph();
    int bxmin, bymin, bxmax, bymax;
    xycart->getViewport(bxmin, bxmax, bymin, bymax);
    // printf( "%d, %d -- %d %d %d %d\n", x, y, bxmin, bxmax, bymin, bymax);
    // fflush( stdout );
    if (bxmin < x && x < bxmax && bymin < y && y < bymax) return c;
  }
  return -1;
}

// .......................................................................

void SXYGraph::activateDisplayCanvas(void) {
  assert(cd_canvas);
  if (cdActivate(cd_canvas) == CD_ERROR) {
     IupMessage( "Erro interno", "Falha na volta de desenho do gráfico!" );
  }
}

// .......................................................................

SXYGraph* SXYGraph::getThis( Ihandle* handle ) {
   return (SXYGraph*) IupGetAttribute( handle, GRAPH_ATTR_NAME );
}

// .......................................................................

int SXYGraph::iupLeaveCallback( Ihandle* h ) {
   SXYGraph* graph = getThis( h );

   int ntasks = graph->getNumTasks();
   for (int t = 0; t < ntasks; t++) {
     SXYTask* tsk = graph->getTask(t);
     assert (tsk);
     if ( tsk->mouseLeave(graph) == CALLBACK_TREATED ) return IUP_DEFAULT;
   }

  if (graph) graph->mouseLeave();

  return IUP_DEFAULT;
}

// .......................................................................

int SXYGraph::iupEnterCallback( Ihandle* h ) {
   SXYGraph* graph = getThis( h );

   int ntasks = graph->getNumTasks();
   for (int t = 0; t < ntasks; t++) {
     SXYTask* tsk = graph->getTask(t);
     assert (tsk);
     if ( tsk->mouseEnter(graph) == CALLBACK_TREATED ) return IUP_DEFAULT;
   }

   if (graph) graph->mouseEnter();
   return IUP_DEFAULT;
}

// .......................................................................

int SXYGraph::iupActionCallback( Ihandle* h ) {
   SXYGraph* graph = getThis( h );
   if (graph) graph->redrawGraph();
   return IUP_DEFAULT;
}

// .......................................................................

int SXYGraph::iupMotionCallback(Ihandle* h, int x, int y, char *r) {
   SXYGraph* graph = getThis( h );
   if (!graph) return IUP_DEFAULT;

   int sft = isshift(r);
   int ctr = iscontrol(r);
   graph->activateDisplayCanvas();
   cdCanvas2Raster( &x, &y );


   int ntasks = graph->getNumTasks();
   for (int t = 0; t < ntasks; t++) {
     SXYTask* tsk = graph->getTask(t);
     assert (tsk);
     if (tsk->mouseMotion(graph, x, y, sft, ctr) == CALLBACK_TREATED) 
         return IUP_DEFAULT;
   }

   graph->mouseMotion(x, y, sft, ctr);
   return IUP_DEFAULT;
}

// .......................................................................

int SXYGraph::iupButtonCallback(Ihandle* h, int b, int e, int x, int y, char *r) {
   SXYGraph* graph = getThis( h );
   if (!graph) return IUP_DEFAULT;

   int sft = isshift(r);
   int ctr = iscontrol(r);
   int but = (b == IUP_BUTTON1 ? 1 : b  == IUP_BUTTON2 ? 2 : 3 );
   graph->activateDisplayCanvas();
   cdCanvas2Raster( &x, &y );

   int ntasks = graph->getNumTasks();
   for (int t = 0; t < ntasks; t++) {
     SXYTask* tsk = graph->getTask(t);
     assert (tsk);
     if (e==1) {
       if (tsk->mouseClick(graph, but, x, y, sft, ctr) == CALLBACK_TREATED) 
          return IUP_DEFAULT;
     }
     else {
       if (tsk->mouseUnclick(graph, but, x, y, sft, ctr) == CALLBACK_TREATED) 
          return IUP_DEFAULT;
     }
   }

   if (e==1) graph->mouseClick(but, x, y, sft, ctr);
   else      graph->mouseUnclick(but, x, y, sft, ctr);

   /* Retorno ao IUP */
   return IUP_DEFAULT;
}

// .......................................................................

int SXYGraph::iupResizeCallback( Ihandle* h, int width, int height ) {
   SXYGraph* graph = getThis( h );
   if (!graph) return IUP_DEFAULT;
   graph->activateDisplayCanvas();
   return IUP_DEFAULT;
}

---

SXY
Tecgraf / PUC-Rio - Computer Graphics Technology Group