---

xygrapl.cpp

Go to the documentation of this file.

/*****************************************************************************/
/* Módulo: xygrppl.cpp                                                       */
/* Autores: Camilo da Fonseca Freire                                         */
/* Data: 11 jul 96                                                           */
/* Comentário:                                                               */
/*    Implementação de métodos da classe especializada, responsável pelo de- */
/* senho de gráficos do tipo polar que tem como principal característica um  */
/* eixo polar (XYPolarAxis).                                                 */
/*****************************************************************************/

#include <stdlib.h>
#include <stdarg.h>
 
#include "xygrapl.h"

const char* xy_id_xypolar_cpp="$Id: xygrapl.cpp,v 1.17 1999/12/09 21:47:46 rborges Exp $";
                                                                
#ifndef NOIUP
XYPolar::XYPolar (Ihandle* canvas,
                  XYCoordinate x,
                  XYCoordinate y,
                  double width,
                  double height,
                      XYRadialGrid* gridr,
                      XYAngGrid* grida,
                      xybool visible)
                      : XYGraph(canvas, x, y, width, height, visible),
                            _gridr(gridr),
                          _grida(grida)
{
   distortion(xyfalse);
}
#endif

XYPolar::XYPolar (cdCanvas* cdcanvas,
                  XYCoordinate x,
                  XYCoordinate y,
                  double width,
                  double height,
                      XYRadialGrid* gridr,
                      XYAngGrid* grida,
                      xybool visible)
                      : XYGraph(cdcanvas, x, y, width, height, visible),
                            _gridr(gridr),
                          _grida(grida)
{
   distortion(xyfalse);
}

XYPolar::~XYPolar (void)
{
   // liberar listas de textos, eixos e máscaras alocadas
}

void XYPolar::setGridR (XYRadialGrid *gridr)
{
   _gridr = gridr;
}

XYRadialGrid* XYPolar::getGridR (void) const
{
   return _gridr;
}

void XYPolar::setGridA (XYAngGrid *grida)
{
   _grida = grida;
}

XYAngGrid* XYPolar::getGridA (void) const
{
   return _grida;
}

XYObject* XYPolar::pick (int px, int py)
{
   XYObject* obj;

   // verifica objetos gráficos
   obj = XYGraph::pick(px, py);

   if (obj != NULL) return obj;

   // testa grade angular
   if (_grida -> pick(px, py))  
          return _grida;

   // testa grade radial
   if (_gridr -> pick(px, py))  
      return _gridr;

   return NULL;
}

XYList<XYObject>* XYPolar::fence (int x0, int y0, int x1, int y1)
{
   XYList<XYObject>* obj;

   obj = XYGraph::fence(x0, y0, x1, y1);

   // testa grade angular
   if (_grida -> fence(x0, y0, x1, y1)) 
       obj -> insert(_grida);

   // testa grade radial
   if (_gridr -> fence(x0, y0,  x1, y1))        
      obj -> insert(_gridr);

   return obj;
}

void XYPolar::calcMaskArea (void)
{
   activateCanvas ();

   XYListIterator<XYAxis> in(&_axes);

   // inicializa coordenadas mínimas com valores máximos possíveis, coordenadas
   // máximas com valores mínimos possíveis
   _ma_xmin = 1.0;
   _ma_xmax = 0.0;
   _ma_ymin = 1.0;
   _ma_ymax = 0.0;

   XYAxis* cont;
   double x, y;
   double size;

   while (!in.End())
   {
      cont = in.Next();

      // consulta posição e tamanho do eixo
      cont -> position(&x, &y);
      size = cont -> size();

      // cálculo da área útil
      _ma_xmin = x - size;
      _ma_xmax = x + size;
      _ma_ymin = y - size;
      _ma_ymax = y + size;
   }
}

void XYPolar::draw(void)
{
   if (visible() == xyfalse)    // invisível!!!
      return;

   activateCanvas();
   defineViewport();

   int x1, y1, x2, y2;
   getViewport (x1, x2, y1, y2);

   draw(x1, y1, x2, y2);
}

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

   activateCanvas();
   propagateViewport();

   XYGraph::maskAreaClear();

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

   if (_grida)  // desenha grade angular
   {
      _grida -> size ((_ma_xmax - _ma_xmin) / 2.);
      _grida -> draw (xmin, ymin, xmax, ymax);
   }

   if (_gridr)  // desenha grade radial
   {
      _gridr -> size ((_ma_xmax - _ma_xmin) / 2.);
      _gridr -> draw (xmin, ymin, xmax, ymax);
   }

   XYGraph::draw(xmin, ymin, xmax, ymax);

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

   XYGraph::flush();
}

void XYPolar::propagateViewport (void) const
{
   // define as áreas de desenho para todos os textos, eixos, máscaras,
   // marcadores, "slices" e legenda que existirem
   XYGraph::propagateViewport();

   int x1, x2, y1, y2;
   getViewport(x1, x2, y1, y2);

   if (_grida)  // define área gráfica para a grade angular
      _grida -> setViewport(x1, x2, y1, y2);

   if (_gridr)  // define área gráfica para a grade radial
      _gridr -> setViewport(x1, x2, y1, y2);
}

void XYPolar::drawMaskArea (void) const
{
   int x1, y1, x2, y2;
   getMaskArea (x1, y1, x2, y2);

   drawMaskArea (x1, y1, x2, y2);
}

void XYPolar::drawMaskArea (int xmin, int ymin, int xmax, int ymax) const
{
   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);

   if (_grida)  // desenha grade angular
      _grida -> draw (xmin, ymin, xmax, ymax);

   if (_gridr)  // desenha grade radial
      _gridr -> draw (xmin, ymin, xmax, ymax);

   XYGraph::drawMaskArea(xmin, ymin, xmax, ymax);

   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