---

xymcabr.cpp

Go to the documentation of this file.

/*****************************************************************************/
/* Módulo: xymcabr.cpp                                                       */
/* Autores: Camilo da Fonseca Freire                                         */
/* Data: 27 jun 96                                                           */
/* Comentário:                                                               */
/*    Implementação de métodos da classe que representa através de barras um */
/* conjunto de dados num gráfico cartesiano.                                 */
/*****************************************************************************/

#include "xymcabr.h"

const char* xy_id_xymcabr_cpp="$Id: xymcabr.cpp,v 1.9 1999/12/09 21:47:46 rborges Exp $";
                                                                
XYCartesianBarMask::XYCartesianBarMask (XYText* name,
                                                          XYSeries* series,
                                                          const XYAxis* x_axis,
                                                          const XYAxis* y_axis,
                                                          long color,
                                                          InteriorStyle style,
                                                          HatchStyle hstyle,
                                                          xybool border,
                                                          long bcolor,
                                                          double displacement,
                                                          double width,
                                                          xybool visible)
                                                          : XYCartesianMask(name, series, x_axis,
                                                                                  y_axis, color,
                                                                                      visible),
                                                                  _style(style),
                                                                  _hstyle(hstyle),
                                                            _border(border),
                                                            _bcolor(bcolor),
                                                            _displacement(displacement),
                                                            _width(width)
{
}

XYCartesianBarMask::XYCartesianBarMask (XYSeries* series,
                                                          const XYAxis* x_axis,
                                                          const XYAxis* y_axis,
                                                          long color,
                                                          InteriorStyle style,
                                                          HatchStyle hstyle,
                                                          xybool border,
                                                          long bcolor,
                                                          double displacement,
                                                          double width,
                                                          xybool visible)
                                                          : XYCartesianMask(series, x_axis,
                                                                            y_axis, color,
                                                                            visible),
                                                            _style(style),
                                                            _hstyle(hstyle),
                                                            _border(border),
                                                            _bcolor(bcolor),
                                                            _displacement(displacement),
                                                            _width(width)
{
}

void XYCartesianBarMask::style (XYMask::InteriorStyle s)
{
   _style = s;
}

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

void XYCartesianBarMask::hstyle (HatchStyle hs)
{
   _hstyle = hs;
}

int XYCartesianBarMask::hstyle (void) const
{
   return _hstyle;
}

void XYCartesianBarMask::bcolor (long bc)
{
   _bcolor = bc;
}

long XYCartesianBarMask::bcolor (void) const
{
   return _bcolor;
}

void XYCartesianBarMask::displacement (double d)
{
   _displacement = d;
}

double XYCartesianBarMask::displacement (void) const
{
   return _displacement;
}

void XYCartesianBarMask::width (double w)
{
   _width = w;
}

double XYCartesianBarMask::width (void) const
{
   return _width;
}

void XYCartesianBarMask::border (xybool b)
{
   _border = b;
}

xybool XYCartesianBarMask::border (void) const
{
   return _border;
}

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

xybool XYCartesianBarMask::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, x1, y1, x2, y2;
   // verifica uma série
   for (int i = 0; i < npoints; ++i)
   {
      s -> point(i, xt, yt);

      x1 = _x_axis -> transform(xt) - _width / 2.;
      y1 = _x_axis -> transform(_y_axis -> min());
      x2 = _x_axis -> transform(xt) + _width / 2.;
      y2 = _y_axis -> transform(yt);

      if (mtPointInRect(px, py, x1, y1, x2, y2))
         return xytrue;
   }

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

xybool XYCartesianBarMask::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 XYCartesianBarMask::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((int)_width);
   cdForeground(_color);

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

void XYCartesianBarMask::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 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
   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;

   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 <= 0)
   {
      // 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 de interior usado para desenhar a série
   cdHatch(_hstyle);
   cdInteriorStyle(_style);

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

   double xt, yt, x1, x2, y1, y2;

   // desenha uma série
   for (int i = 0; i < npoints; ++i)
   {
      s -> point(i, xt, yt);

      x1 = _x_axis -> transform(xt) - _width / 2.;
      y1 = _y_axis -> transform(_y_axis -> min());
      x2 = _x_axis -> transform(xt) + _width / 2.;
      y2 = _y_axis -> transform(yt);

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

      // cor da barra
      cdForeground(_color);

      // desenha barra para cada ponto da série
      wdBox (x1, x2, y1, y2);

      if (_border == xytrue)
      {
         // cor da fronteira
         cdForeground(_bcolor);

         // desenha fronteira da barra
         wdBegin(CD_CLOSED_LINES);
         wdVertex(x1,y1);
         wdVertex(x2,y1);
               wdVertex(x2,y2);
               wdVertex(x1,y2);
               wdEnd();
      }

      cdFlush();
   }

   // 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 XYCartesianBarMask::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, x1, x2, y1, y2;

   s -> point(0, xt, yt);

   x1 = _x_axis -> transform(xt) - _width / 2.;
   y1 = _y_axis -> transform(_y_axis -> min());
   x2 = _x_axis -> transform(xt) + _width / 2.;
   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 = 1; i < npoints; ++i)
   {
      s -> point(i, xt, yt);

      x1 = _x_axis -> transform(xt) - _width / 2.;
      y1 = _y_axis -> transform(_y_axis -> min());
      x2 = _x_axis -> transform(xt) + _width / 2.;
      y2 = _y_axis -> transform(yt);

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

      txmin = MIN3(x1, x2, txmin);
      tymin = MIN3(y1, y2, tymin);
      txmax = MAX3(x1, x2, txmax);
      tymax = MAX3(y1, y2, tymax);
                                
      cdFlush();
   }

   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