---

xymcastmk.cpp

Go to the documentation of this file.

/*****************************************************************************/
/* Módulo: xymcastmk.cpp                                                     */
/* Autores: Carlos Henrique Levy, Jaudênia Cavalcante e camilo Freire        */
/* Data: 24 mai 2000                                                         */
/* Comentário:                                                               */
/*    Implementação de métodos da classe especializada que representa através*/
/* de segmentos de retas conectados (de modo a dar um aspecto escada)  e     */
/* marcas um conjunto de dados num gráfico cartesiano.                       */
/*****************************************************************************/

#include "xymcastmk.h"

const char* xy_id_xymcastmk_cpp="$Id: xymcastmk.cpp,v 1.3 2000/06/14 19:13:01 camilo Exp $";
                                                                
XYCartesianStepMarkMask::XYCartesianStepMarkMask (XYText* name,
                                                  XYSeries* series,
                                                  const XYAxis* x_axis,
                                                  const XYAxis* y_axis,
                                                  long color,
                                                  int  width,
                                                  LineStyle style,
                                                  int  size,
                                                  MarkStyle mark,
                                                  xybool  visible)
                        : XYCartesianStepMask(name, series, x_axis, y_axis,
                                              color, width, style, visible),
                        _size(size),
                        _mark(mark)
{
}

XYCartesianStepMarkMask::XYCartesianStepMarkMask (XYSeries* series,
                                                  const XYAxis* x_axis,
                                                  const XYAxis* y_axis,
                                                  long color,
                                                  int  width,
                                                  LineStyle style,
                                                  int  size,
                                                  MarkStyle mark,
                                                  xybool  visible)
                        : XYCartesianStepMask(series, x_axis, y_axis,
                                              color, width, style, visible),
                        _size(size),
                        _mark(mark)
{
}

void XYCartesianStepMarkMask::size (int s)
{
   _size = s;
}

int XYCartesianStepMarkMask::size (void) const
{
   return _size;
}

void XYCartesianStepMarkMask::mark (XYMask::MarkStyle m)
{
   _mark = m;
}

int XYCartesianStepMarkMask::mark (void) const
{
   return _mark;
}

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

xybool XYCartesianStepMarkMask::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;

   setWindow (_x_axis -> transform(_x_axis -> min()),
                    _x_axis -> transform(_x_axis -> max()),
                  _y_axis -> transform(_y_axis -> min()),
                  _y_axis -> transform(_y_axis -> max()));

   setViewport();

   // 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);

   // 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++;


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

   // define tolerância para 1.5 milimetros 
   int tol_dx,tol_dy;
   wdMM2Pixel(1.5, 1.5, &tol_dx, &tol_dy); 
   double yaxis_min = _y_axis -> transform(_y_axis -> min()); 
   double yaxis_max = _y_axis -> transform(_y_axis -> max()); 
   double tol_y = tol_dy * ( yaxis_max - yaxis_min) / (_ymax - _ymin + 1);
   double xaxis_min = _x_axis -> transform(_x_axis -> min());
   double xaxis_max = _x_axis -> transform(_x_axis -> max());
   double tol_x = tol_dx * ( xaxis_max - xaxis_min) / (_xmax - _xmin + 1);
   double oldtol = mtTolerance(tol_y);
          
   // tolerância considerada por causa do desenho da marca que ocupa vários
   // pixels da tela
   int tol = _size;
   
   double x2, y2;

   // verifica uma série nos dois segmentos do degrau
   int    iprevious = ifirst;
   for (int i = (ifirst+1); i < npoints; ++i)
   {
      if (s -> point(i, xt, yt))
      {
        x2 = _x_axis -> transform(xt);
        y2 = _y_axis -> transform(yt);

        mtTolerance(tol_y);
        xybool r1 = mtPointInLine(px, py, x1, y1, x2, y1);
        mtTolerance(tol_x);
        xybool r2 = mtPointInLine (py, px, y1, x2, y2, x2); // Inverte x e y

        if ( ( r1 || r2 ) && (i == (iprevious+1)) )
        {
           cdClip(mode);
           // restaura a região de clip anterior
           cdClipArea(oldclip_xmin, oldclip_xmax, oldclip_ymin, oldclip_ymax);
          
           mtTolerance(oldtol);
           return xytrue;
        }

        //if (mtPointInMark(px, py, x1, y1, tol)) return xytrue;

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

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

   mtTolerance(oldtol);
   return xyfalse;
}

void XYCartesianStepMarkMask::drawIcon (int xmin, int ymin, int xmax, int ymax)
                                                const
{
   int xmid = (int)((double)(xmax + xmin) / 2);
   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, ymin, xmid, ymin);
   cdLine (xmid, ymin, xmid, ymax);
   cdLine (xmid, ymax, xmax, ymax);

   // ativa estilo, tamanho e cor da marca usada para desenhar a série
   cdMarkType(_mark);
   wdMarkSize(_size*.25);
   cdForeground(_color);

   cdMark (xmid, ymid);
}

void XYCartesianStepMarkMask::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);

   // novo domínio
   double begin, end;

   // define os parâmetros de visualização para o domínio dos 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
   setWindow (_x_axis -> min(), _x_axis -> max(), _y_axis -> min(),
              _y_axis -> max());

   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;

   // clipa dentro do grafico
   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:

   // transforma coordenadas máximas e mínimas de acordo com o tipo dos eixos
   // ativos e usa esses valores para a nova window
   setWindow (_x_axis -> transform(_x_axis -> min()),
                  _x_axis -> transform(_x_axis -> max()),
                  _y_axis -> transform(_y_axis -> min()),
                  _y_axis -> transform(_y_axis -> max()));

   setViewport();

   // ativa estilo, largura e cor da linha usada para desenhar a série
   cdMarkType(_mark);
   wdMarkSize(_size*.25);
   cdLineStyle(style());
   cdLineWidth(width());
   cdForeground(_color);

   // 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);

   cdWriteMode(CD_REPLACE);

   // obtem primeiro ponto 
   double xt, yt;

   int    ifirst=0;
   while (!(s -> point(ifirst, xt, yt))) ifirst++;

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

   double x2, y2;
   int vx1, vy1;
   int    iprevious=ifirst;

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

        // desenha traço da série       como sendo um degrau de escada
        if (i == (iprevious+1))
        { wdLine (x1, y1, x2, y1);
          wdLine (x2, y1, x2, y2);
        }

         // calcula os novos valores em coordenadas da tela
         wdWorld2Canvas (x1, y1, &vx1, &vy1);

         // desenha marca da série
         cdMark (vx1, vy1);

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

   // restaura o atual modo de clipping
   cdClipArea(xmin, xmax, ymin, ymax);

   // 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);
}

---

XY
Tecgraf / PUC-Rio - Computer Graphics Technology Group