---

xymcaln.cpp

Go to the documentation of this file.

/*****************************************************************************/
/* Módulo: xymcaln.cpp                                                       */
/* Autores: Carlos Henrique Levy e Jaudênia Cavalcante                       */
/* Data: 08 mar 96                                                           */
/* Comentário:                                                               */
/*    Implementação de métodos da classe especializada que representa através*/
/* de segmentos de retas conectados um conjunto de dados num gráfico cartesi */
/* ano.                                                                      */
/*****************************************************************************/

#include "xymcaln.h"

const char* xy_id_xymcaln_cpp="$Id: xymcaln.cpp,v 1.16 2003/01/03 17:44:33 clinio Exp $";
                                                                
XYCartesianLineMask::XYCartesianLineMask (XYText* name,
                                          XYSeries* series,
                                          const XYAxis* x_axis,
                                          const XYAxis* y_axis,
                                          long color,
                                          int  width,
                                          LineStyle style,
                                          xybool  visible)
                                          : XYCartesianMask(name, series,
                                                            x_axis, y_axis,
                                                            color, visible),
                                            _width(width),
                                            _style(style)
{
}

XYCartesianLineMask::XYCartesianLineMask (XYSeries* series,
                                          const XYAxis* x_axis,
                                          const XYAxis* y_axis,
                                          long color,
                                          int  width,
                                          LineStyle style,
                                          xybool  visible)
                                          : XYCartesianMask(series, x_axis,
                                                            y_axis, color,
                                                            visible),
                                            _width(width),
                                            _style(style)
{
}

void XYCartesianLineMask::width (int w)
{
   _width = w;
}

int XYCartesianLineMask::width (void) const
{
   return _width;
}

void XYCartesianLineMask::style (XYMask::LineStyle s)
{
   _style = s;
}

int XYCartesianLineMask::style (void) const
{
   return _style;
}

void XYCartesianLineMask::draw (void)
{
   draw(_xmin, _ymin, _xmax, _ymax);
}

xybool XYCartesianLineMask::pick (int x, int y)
{
   if (visible() == xyfalse)    // invisível!!!
      return xyfalse;

   XYSeries* s = (XYSeries *) _series;

   int npoints = s -> numPoints();

   // teste de inconsistência
   if ((npoints <= 1) || (x < _xmin) || (_xmax < x) || (y < _ymin) ||
       (_ymax < y))
      return xyfalse;

   setMacWindow();
   setViewport();

   // guarda estado do clipping
   int oldmode = cdClip(CD_CLIPON);
   int oldclip_xmin, oldclip_xmax, oldclip_ymin, oldclip_ymax;
   cdGetClipArea (&oldclip_xmin, &oldclip_xmax, &oldclip_ymin, &oldclip_ymax);
   
   // define nova região de clip
   cdClipArea(_xmin, _xmax, _ymin, _ymax);

   // converte coordenadas (x, y) em pixels para coordenadas do mundo
   double px, py;
   wdCanvas2World (x, y, &px, &py);

   double xt, yt;

   int    ifirst=0;                                    
   while (!(s -> point(ifirst, xt, yt)) && ifirst < npoints) ifirst++;    
   if (ifirst >= npoints) return xyfalse;

   double x1 = _x_axis -> transform(xt);
   double y1 = _y_axis -> transform(yt);
   int px1,py1;
   wdWorld2Canvas(x1, y1, &px1, &py1);
    
   // define tolerância para 2.0 milimetros  
   int tol_dx,tol_dy;
   cdMM2Pixel(2.0, 2.0, &tol_dx, &tol_dy); 
   tol_dy = _width > tol_dy ? _width : tol_dy; // coerente com largura da line
   double oldtol = mtTolerance((double)tol_dy);
   //double oldtol = mtTolerance(tol_dy * (_y_axis -> transform(_y_axis -> max())
   //                       - _y_axis -> transform(_y_axis -> min()))
   //                         / (_ymax - _ymin + 1));
   
   // verifica uma série
   xybool hit = xyfalse;
   int  iprevious = ifirst;
   for (int i = (ifirst+1); i < npoints; ++i)
   {
      int px2,py2;
     
      if (s -> point(i, xt, yt))
      {
        double x2 = _x_axis -> transform(xt);
        double y2 = _y_axis -> transform(yt);
        wdWorld2Canvas(x2, y2, &px2, &py2);

        if ((mtPointInLineEx(x, y, px1, py1, px2, py2)) && (i==(iprevious+1)))
        {
          hit = xytrue; // acertou pick !
          break;
        }
   
        px1 = px2;
        py1 = py2;
        iprevious = i;
      }
   }

   // restaura ao modo anterior
   cdClip(oldmode);
   cdClipArea(oldclip_xmin, oldclip_xmax, oldclip_ymin, oldclip_ymax);
   mtTolerance(oldtol);
 
   return hit;
}

xybool XYCartesianLineMask::fence (int x2, int y2, int x3, int y3)
{
   if (visible() == xyfalse)           // invisível!!!
      return xyfalse;

   // limites da menor caixa que contém uma máscara
   int x0, y0, x1, y1;
   boundingBox (x0, y0, x1, y1);

   return mtInclude (x0, y0, x1, y1, x2, y2, x3, y3);
}

void XYCartesianLineMask::drawIcon (int xmin, int ymin, int xmax, int ymax)
                                                const
{
   int ymid = (int)((double)(ymax + ymin) / 2);

   // ativa estilo, largura e cor da linha usada para desenhar a série
   cdLineStyle(_style);
   cdLineWidth(_width);
   cdForeground(_color);

   cdLine (xmin, ymid, xmax, ymid);
}

void XYCartesianLineMask::draw (int xmin, int /* ymin */, int xmax, int /* ymax */) const
{
   if (visible() == xyfalse)  // invisível!!!
      return;

   XYSeries* s = (XYSeries *) _series;

   // define domínio da série nos limites da área a ser desenhada:

   // domínio original da série
   double old_begin, old_end;
   s -> domain(&old_begin, &old_end);
   double old_xf, old_xl, old_yf, old_yl;
   s -> point(0, old_xf, old_yf);
   s -> point(s -> numPoints()-1, old_xl, old_yl);

   // novo domínio
   double begin, end;

   // define os parâmetros de visualização para o domínio do eixos na
   // região de desenho das máscaras. Isto é necessário para se poder
   // calcular os novos limites do eixo X em coordenadas do mundo
   setMacWindow();
   setViewport();

   // calcula os novos limites no eixo X, em coordenadas do mundo
   wdCanvas2World (xmin, 0, &begin, 0);
   wdCanvas2World (xmax, 0, &end, 0);

   // calcula o novo domínio para a série que é o domínio que está dentro
   // da região que vai ser desenhada. Agora, se a área não intercepta o
   // domínio, então retorna porque não há nada para ser desenhado
   if ((begin > old_end) || (end < old_begin))
      return;

   if (begin < old_begin)
      begin = old_begin;

   if (end > old_end)
      end = old_end;
        
   // define o novo domínio
   s -> domain(begin, end);

   // número de pontos na série
   int npoints = s -> numPoints();

   // teste de inconsistência
   //if (npoints <= 1)
   //{
      // restaura valores originais do domínio da série
   //   s -> domain(old_begin, old_end);
   //   return;
   //}

   // começa a desenhar:

   // ativa estilo, largura e cor da linha usada para desenhar a série
   cdLineStyle(_style);
   cdLineWidth(_width);
   cdForeground(_color);

   cdWriteMode(CD_REPLACE);

   // guarda o atual modo de clipping
   int mode = cdClip(CD_CLIPON);

   // guarda a região de clip corrente
   int oldclip_xmin, oldclip_xmax, oldclip_ymin, oldclip_ymax;
   cdGetClipArea (&oldclip_xmin, &oldclip_xmax, &oldclip_ymin, &oldclip_ymax);
   // define nova região de clip
   cdClipArea(_xmin, _xmax, _ymin, _ymax);
   
   double xt, yt;
   int    ifirst=0;
   int    iprevious=ifirst;

   // Gambiarra para o Camilinho... -- Mac :)
   int gamb = 0;
   while (!(s -> point(ifirst, xt, yt)) && ifirst < npoints) {
      ifirst++;    
      gamb=1;
   }
   if (ifirst >= npoints) return;
   if ( gamb ) ifirst--;

   double x1 = _x_axis -> transform(xt);
   double y1 = _y_axis -> transform(yt);

   double x2, y2;

   if (old_xf < begin || old_xf > end ) 
   {
      if (s -> point((unsigned)-1, xt, yt))
      {
        x2 = _x_axis -> transform(xt);
        y2 = _y_axis -> transform(yt);


        x2 = _x_axis -> transform(xt);
        y2 = _y_axis -> transform(yt);

        // desenha traço da série
        wdLine (x2, y2, x1, y1);
      }
   }

   // desenha uma série
   int i = 0;
   for (i = (ifirst+1); i < npoints; ++i)
   {
       if (s -> point(i, xt, yt))
       {
         x2 = _x_axis -> transform(xt);
         y2 = _y_axis -> transform(yt);

         // desenha tra\147o da s\151rie
         // caso os dois pontos sejam consecutivos
         if (i == (iprevious+1)) wdLine (x1, y1, x2, y2);

         x1 = x2;
         y1 = y2;
         iprevious = i;
       }
   }

   if ( old_xl < begin || old_xl > end )
   {
       if (s -> point(i, xt, yt))
       {
         x2 = _x_axis -> transform(xt);
         y2 = _y_axis -> transform(yt);

         // desenha tra\147o da s\151rie
         wdLine (x1, y1, x2, y2);
       }
   }

   // restaura valores originais do domínio da série
   s -> domain(old_begin, old_end);

   cdClip(mode);
   // restaura a região de clip anterior
   cdClipArea(oldclip_xmin, oldclip_xmax, oldclip_ymin, oldclip_ymax);
}

void XYCartesianLineMask::boundingBox (int& bxmin, int& bymin, int& bxmax,
                                       int& bymax) const
{
   if (visible() == xyfalse)  // invisível!!!
      return;

   XYSeries* s = (XYSeries *) _series;

   // número de pontos na série
   int npoints = s -> numPoints();

   double xt, yt;

   s -> point(0, xt, yt);
   double x1 = _x_axis -> transform(xt);
   double y1 = _y_axis -> transform(yt);

   s -> point(1, xt, yt);
   double x2 = _x_axis -> transform(xt);
   double y2 = _y_axis -> transform(yt);

   // controle de ponto flutuante
   if (mtEqual(x1, x2))
      x2 = x1;
   if (mtEqual(y1, y2))
      y2 = y1;

   // inicializa boundingBox
   double txmin = MIN(x1, x2);
   double tymin = MIN(y1, y2);
   double txmax = MAX(x1, x2);
   double tymax = MAX(y1, y2);

   // verifica uma série
   for (int i = 2; i < npoints; ++i)
   {
      x1 = x2;
      y1 = y2;

      s -> point(i, xt, yt);
      x2 = _x_axis -> transform(xt);
      y2 = _y_axis -> transform(yt);

      // controle de ponto flutuante
      if (mtEqual(x1, x2))
         x2 = x1;
      if (mtEqual(y1, y2))
         y2 = y1;

      txmin = MIN(x2, txmin);
      tymin = MIN(y2, tymin);
      txmax = MAX(x2, txmax);
      tymax = MAX(y2, tymax);
   }

   wdWorld2Canvas(txmin, tymin, &bxmin, &bymin);
   wdWorld2Canvas(txmax, tymax, &bxmax, &bymax);

   // restringe a boundingBox a área de desenho da máscara,
   // caso ela a ultrapasse

   if (bxmin > _xmin)
      bxmin = _xmin;

   if (bxmax > _xmax)
      bxmax = _xmax;

   if (bymin > _ymin)
      bymin = _ymin;

   if (bymax > _ymax)
      bymax =_ymax;
}

---

XY
Tecgraf / PUC-Rio - Computer Graphics Technology Group