---

xyrgrid.cpp

Go to the documentation of this file.

/*****************************************************************************/
/* Módulo: xyrgrid.cpp                                                       */
/* Autores: Camilo do Foseca Freire                                          */
/* Data: 11 jul 96                                                           */
/* Comentário:                                                               */
/*    Implementação de métodos da classe que define um tipo especial de eixo */
/* que desenha circulos concêntricos, centrados na origem do eixo, com raios */
/* definidos pelo usuário.                                                   */
/*****************************************************************************/

#include <stdlib.h>
#include <math.h>
#include <stdio.h>

#include "xyrgrid.h"
                                                                
const char* xy_id_xyrgrid_cpp="$Id: xyrgrid.cpp,v 1.5 1999/12/09 21:47:46 rborges Exp $";
                                                                
XYRadialGrid::XYRadialGrid (double mn,
                                          double mx,
                                          double p,
                                        long color,
                                        double step,
                                        xybool visible)
                                        : XYAxis(mn, mx, .5, .5, color, 1., 0., step,
                                     xyfalse, visible),
                                          _first(p),
                                                _style(continuous)
{
}

void XYRadialGrid::first (double f)
{
   _first = f;
}

double XYRadialGrid::first (void) const
{
   return _first;
}

void XYRadialGrid::style (int s)
{
   _style = s;
}

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

xybool XYRadialGrid::pick (int px, int py)
{
   if (visible() == xyfalse)    // invisível!!!
      return xyfalse;

   // passo normalizado na grade em relação ao canvas
   double s = _step * _size / (_mx - _mn);

   // (x0, y0) centro dos círculos da grade
   double x0, y0;
   position (&x0, &y0);

   int px0, py0, px1, py1;
   double x1, y1;

   double dx = 0.;

   for (double p = _first; p <= _mx; p += _step)
   {
      x1 = x0 + dx * 2.;
      y1 = y0 + dx * 2.;

      // converte coordenadas do mundo para coordenadas em pixel
      wdWorld2Canvas (x0, y0, &px0, &py0);
      wdWorld2Canvas (x1, y1, &px1, &py1);

      // verifica se o ponto está sobre uma linha da grade
      if (mtPointInCircle(px, py, px0, py0, px1, py1))
         return xytrue;

      dx += s;
   }

   return xyfalse;
}

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

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

   // passo normalizado na grade em relação ao canvas
   double s = _step * _size / (_mx - _mn);

   // verifica se a grade é muito compacta
   if (s <= 0.01)
      return;

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

   // (x0, y0) centro dos círculos da grade
   double x0, y0;
   position (&x0, &y0);

   // desenha grade com linha sólida mais fina possível e com cor definida
   // pelo usuário
   cdLineWidth  (1);
   cdLineStyle  (continuous);
   cdForeground (_color);

   double dx = 0.;

   for (double p = _first; p <= _mx; p += _step)
   {
      // desenha círculo da grade
      wdArc(x0, y0, dx * 2., dx * 2., 0., 360.);

      dx += s;
   }

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

void XYRadialGrid::boundingBox (int& xmin, int& ymin, int& xmax, int& ymax)
                                const
{
   if (visible() == xyfalse)    // invisível!!!
      return;

   // passo normalizado na grade em relação ao canvas
   double s = _step * _size / (_mx - _mn);

   // verifica se a grade é muito compacta
   if (s <= 0.01)
      return;

   // (x0, y0) centro dos círculos da grade
   double x0, y0;
   position (&x0, &y0);

   int bx1, by1;
   wdWorld2Canvas (x0, y0, &bx1, &by1);

   // inicializa boundingBox
   xmin = bx1;
   ymin = by1;
   xmax = bx1;
   ymax = by1;

   //double x1, y1;
   double dx = 0.;

   for (double p = _first; p <= _mx; p += _step)
   {
      // boundingBox da grade
      xmin = MIN(bx1, xmin);
      ymin = MIN(by1, ymin);
      xmax = MAX(bx1, xmax);
      ymax = MAX(by1, ymax);

      dx += s;
   }
}

---

XY
Tecgraf / PUC-Rio - Computer Graphics Technology Group