---

xygra.cpp

Go to the documentation of this file.

/*****************************************************************************/
/* Módulo: xygra.cpp                                                          */
/* Autores: Carlos Henrique Levy e Jaudênia Cavalcante                       */
/* Data: 26 fev 96                                                           */
/* Comentário:                                                               */
/*    Implementação de métodos da classe abstrata que manipula de forma única*/
/* um conjunto de eixos, (XYAxis), marcadores (XYMarker), regiões (XYSlice), */
/* curvas (XYMask), legenda (XYLegend) e títulos (XYText) numa área de um can*/
/* vas do CD. O layout básico de um gráfico é os títulos, um embaixo do outro*/
/* começando pelo topo da área gerenciada pelo gráfico, a legenda e os eixos */
/* limitando uma região (mask area) onde curvas, marcadores e regiões são de */
/* senhados.                                                                 */
/*****************************************************************************/

#include <stdlib.h>

#include "xygra.h"
#include "cdps.h"

const char* xy_id_xygr_cpp="$Id: xygra.cpp,v 1.36 2002/01/23 16:12:49 clinio Exp $";
                                                                
#ifndef NOIUP
XYGraph::XYGraph (Ihandle* canvas,
                  XYCoordinate x,
                  XYCoordinate y,
                  double width,
                  double height,
                        xybool visible)
                      : XYObject(x, y, visible),
                        _canvas(canvas),
                        _cdcanvas(NULL),
                        _cvimage(NULL),
                        _image(NULL),
                        _image_w(0),
                        _image_h(0),
                        _legend(NULL),
                        _color(XY_GRAY),
                        _ma_color(XY_WHITE),
                        _width(width),
                        _height(height),
                        _ma_xmin(0.0),
                        _ma_xmax(1.0),
                        _ma_ymin(0.0),
                        _ma_ymax(1.0),
                        _distortion(xytrue),
                        _doublebuffering(xyfalse),
                    _dont_destroy_cdcanvas( xyfalse )
{
   activateCanvas();
   setWindow();
   defineViewport();
   propagateViewport();
}
#endif

XYGraph::XYGraph (cdCanvas* cdcanvas,
                  XYCoordinate x,
                  XYCoordinate y,
                  double width,
                  double height,
                        xybool visible)
                      : XYObject(x, y, visible),
                        _canvas(NULL),
                                            _cdcanvas(cdcanvas),
                      _cvimage(NULL),
                      _image(NULL),
                          _image_w(0),
                        _image_h(0),
                        _legend(NULL),
                        _color(XY_GRAY),
                        _ma_color(XY_WHITE),
                        _width(width),
                                _height(height),
                                                  _ma_xmin(0.0),
                                                  _ma_xmax(1.0),
                    _ma_ymin(0.0),
                    _ma_ymax(1.0),
                    _distortion(xytrue),
                        _doublebuffering(xyfalse),
                    _dont_destroy_cdcanvas( xytrue )
{
   activateCanvas();
   setWindow();
   defineViewport();
   propagateViewport();
}

XYGraph::~XYGraph (void)
{
   // Libera imagem 
   if (_cvimage)
     cdKillCanvas (_cvimage);
   if (_image)
     cdKillImage (_image);

   // libera o canvas CD usado, se existir canvas IUP
   if (_cdcanvas && _dont_destroy_cdcanvas == xyfalse )
      cdKillCanvas (_cdcanvas);
}

void XYGraph::position (double x, double y)
{
   XYObject::position(x, y);
   defineViewport();
}

void XYGraph::position (int xp, int yp)
{
   XYObject::position(xp, yp);
   defineViewport();
}

void XYGraph::position (double* x, double* y) const
{
   int    w, h;      // tamanho do canvas em pixel
   cdGetCanvasSize(&w, &h, NULL, NULL);
   XYGraph* g = (XYGraph*) this;

   // posicao do grafico deve ser calculada em relacao ao canvas inteiro, 
   // sendo o unico objeto XY que sofre esta restricao 
   int x1, y1, x2, y2;
   g->getViewport (x1, x2, y1, y2); // salva viewport atual
   g->setViewport (0, w-1, 0, h-1);   // canvas inteiro
   XYObject::position(x, y);
   g->setViewport (x1, x2, y1, y2); // retorna ao original
}

void XYGraph::position (int* xp, int* yp) const
{
   int    w, h;      // tamanho do canvas em pixel
   cdGetCanvasSize(&w, &h, NULL, NULL);
   XYGraph* g = (XYGraph*) this;

   // posicao do grafico deve ser calculada em relacao ao canvas inteiro, 
   // sendo o unico objeto XY que sofre esta restricao 
   int x1, y1, x2, y2;
   g->getViewport (x1, x2, y1, y2); // salva viewport atual
   g->setViewport (0, w-1, 0, h-1);   // canvas inteiro
   XYObject::position(xp, yp);
   g->setViewport (x1, x2, y1, y2); // retorna ao original
}

XYCoordinate* XYGraph::position (void)
{
   return XYObject::position();
}

void XYGraph::setCdCanvas (cdCanvas* c)
{
   _cdcanvas = c;
}

cdCanvas* XYGraph::getCdCanvas (void) const
{
   return _cdcanvas;
}

cdCanvas* XYGraph::canvasImage (cdCanvas* cvimage)
{
   cdCanvas* old = _cvimage;
   _cvimage = cvimage;
   return old;
}

cdCanvas* XYGraph::canvasImage (void)
{
   return _cvimage;
}

void XYGraph::createImage (int w, int h)
{
   _image_w = w;
   _image_h = h;
   _image   = cdCreateImage (_image_w, _image_h);
}

void XYGraph::insert (XYText* text)
{
   text -> insertAction((XYGraph *)this);
   _titles.insert(text);
}

void XYGraph::insert (XYAxis* axis)
{
   axis -> insertAction((XYGraph *)this);
   _axes.insert(axis);
}

void XYGraph::insert (XYMask* mask)
{
   mask -> insertAction((XYGraph *)this);
   _masks.insert(mask);
}

void XYGraph::insert (XYMarker* marker)
{
   marker -> insertAction((XYGraph *)this);
   _markers.insert(marker);
}

void XYGraph::insert (XYSlice* slice)
{
   slice -> insertAction((XYGraph *)this);
   _slices.insertEnd(slice);
}

void XYGraph::insert (XYArea* area)
{
   area -> insertAction((XYGraph *)this);
   _areas.insertEnd(area);
}

void XYGraph::insert (XYObject* decorator)
{
   _decorators.insertEnd(decorator);
}

void XYGraph::remove (XYText* text)
{
   text -> removeAction((XYGraph *)this);
   _titles.remove(text);
}

void XYGraph::remove (XYAxis* axis)
{
   axis -> removeAction((XYGraph *)this);
   _axes.remove(axis);
}

void XYGraph::remove (XYMask* mask)
{
   mask -> removeAction((XYGraph *)this);
   _masks.remove(mask);
}

void XYGraph::remove (XYMarker* marker)
{
   marker -> removeAction((XYGraph *)this);
   _markers.remove(marker);
}

void XYGraph::remove (XYArea* area)
{
   area -> removeAction((XYGraph *)this);
   _areas.remove(area);
}

void XYGraph::remove (XYSlice* slice)
{
   slice -> removeAction((XYGraph *)this);
   _slices.remove(slice);
}

void XYGraph::remove (XYObject* decorator)
{
   _decorators.remove(decorator);
}

XYList<XYText>& XYGraph::text (void)
{
   return _titles;
}

XYList<XYAxis>& XYGraph::axis (void)
{
   return _axes;
}

XYList<XYMask>& XYGraph::mask (void)
{
   return _masks;
}

XYList<XYMarker>& XYGraph::marker (void)
{
   return _markers;
}

XYList<XYArea>& XYGraph::area (void)
{
   return _areas;
}

XYList<XYSlice>& XYGraph::slice (void)
{
   return _slices;
}

XYList<XYObject>& XYGraph::decorator (void)
{
   return _decorators;
}

void XYGraph::legend (XYLegend* leg)
{
   // Compartilha mesma lista de mascaras
   leg -> mask(&_masks); 
   
   _legend = leg;
}

XYLegend* XYGraph::legend (void) const
{
   return _legend;
}

void XYGraph::backgroundColor (long color)
{
   _color = color;
}

long XYGraph::backgroundColor (void) const
{
   return _color;
}

void XYGraph::maskAreaColor (long color)
{
   _ma_color = color;
}

long XYGraph::maskAreaColor (void) const
{
   return _ma_color;
}

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

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

void XYGraph::height (double h)
{
   _height = h;
   defineViewport();
}

double XYGraph::height (void) const
{
   return _height;
}

void XYGraph::setMaskArea (double xmin, double ymin, double xmax,
                                             double ymax)
{
   _ma_xmin = xmin;
   _ma_ymin = ymin;
   _ma_xmax = xmax;
   _ma_ymax = ymax;
}

void XYGraph::getMaskArea (double& xmn, double& ymn, double& xmx,
                                             double& ymx) const
{
   xmn = _ma_xmin;
   ymn = _ma_ymin;
   xmx = _ma_xmax;
   ymx = _ma_ymax;
}

void XYGraph::distortion (xybool d)
{
   _distortion = d;
}

xybool XYGraph::distortion (void) const
{
   return _distortion;
}
                
xybool XYGraph::doubleBuffering (xybool on)
{
   xybool old = _doublebuffering;
   _doublebuffering = on;

   return old;
}

xybool XYGraph::doubleBuffering (void) const
{
   return _doublebuffering;
}

void XYGraph::defineViewport (void)
{
   int w, h;         // tamanho do canvas em pixel
   double wmm, hmm;  // tamanho do canvas em milímetros
   cdGetCanvasSize(&w, &h, &wmm, &hmm);

   double xd, yd;
   position (&xd, &yd);

   int x1, x2, y1, y2;  // coordenadas da viewport

   if (_distortion)
   {
      // canto inferior esquerdo no canvas
      x1 = (int) (xd * (w - 1));
      y1 = (int) (yd * (h - 1));

      // canto superior direito no canvas( + 0.5 : round )
      x2 = (int) (x1 + (_width  * (w - 1)  + (double)0.5));
      y2 = (int) (y1 + (_height * (h - 1)  + (double)0.5));
   }
   else
   {
      // tamanho da viewport quadrada em milímetros
      double square = wmm > hmm ? hmm : wmm;

      double xppm = w / wmm;             // pixel por milímetro em x
      double yppm = h / hmm;             // pixel por milímetro em y

      int xpix = (int) (square * xppm);  // tamanho em pixel, em x
      int ypix = (int) (square * yppm);  // tamanho em pixel, em y

      // centraliza viewport no canvas
      x1 = (int) ((w - xpix) / 2.);
      x2 = x1 + xpix;

      y1 = (int) ((h - ypix) / 2.);
      y2 = y1 + ypix;
   }

   XYGraph* graph = (XYGraph *) this;
   graph -> setViewport (x1, x2, y1, y2);
}

int XYGraph::activateCanvas (void) const
{
#ifndef NOIUP
   // define um canvas CD, se ele ainda não existe
   if (_cdcanvas == NULL)
   {
      XYGraph* t = (XYGraph*) this;
      t -> setCdCanvas(cdCreateCanvas (CD_IUP, _canvas));
   }
#endif

   if (_cdcanvas != NULL)
   {
      // ativa canvas CD
      int rc = wdActivate(_cdcanvas);

      // se não conseguir ativar o canvas CD, retorna mensagem de erro
      if (rc == CD_ERROR)
         return rc;

      cdBackground(_color);
      setViewport();
      setWindow ();

      // se double-buffering cria imagem (caso não exista) e a define como o
      // canvas CD corrente
      if (_doublebuffering)
      {
         // se não existe canvas CD para imagem, então cria
         if (_cvimage == NULL)
         {
            int w, h;
            cdGetCanvasSize (&w, &h, NULL, NULL);

            XYGraph* g = (XYGraph*) this;

                // cria uma imagem, se ela tiver um tamanho diferente da imagem que
                  // já existe
                  if ((w != _image_w) || (_image_h != h))
            {
                   if (_image)
                  cdKillImage (_image);
                
               g -> createImage (w, h);

               if (_image == NULL)
                 return CD_ERROR;
            }

                  // Cria/Ativa canvas p/ imagem 
                              g -> canvasImage (cdCreateCanvas (CD_IMAGE, _image));
                        rc = wdActivate(_cvimage);

                  // se não conseguir ativar o canvas CD, retorna mensagem de erro
            if (rc == CD_ERROR)
               return rc;
                       
            // N limpa com cor de fundo p/ ficar consistente com o modo sem doublebuffer
            cdClear();
               }
                 
         if (_cvimage != NULL)
         {
            // define canvas CD da imagem como corrente
            rc = wdActivate(_cvimage);

            // se não conseguir ativar o canvas da imagem, retorna mensagem
            // de erro
            if (rc == CD_ERROR)
               return rc;

            cdBackground(_color);
            setViewport();
            setWindow ();
         }
         else
           return CD_ERROR;
      }

      return CD_OK;
   }
             
   return CD_ERROR;
}

void XYGraph::getMaskArea (int& xmn, int& ymn, int& xmx, int& ymx) const
{
   int x1, y1, x2, y2;
   getViewport(x1, x2, y1, y2);

   // define região de desenho das máscaras
   xmn = (int) (x1 + _ma_xmin * (x2 - x1));
   ymn = (int) (y1 + _ma_ymin * (y2 - y1) - 1);
   xmx = (int) (x1 + _ma_xmax * (x2 - x1) + 1);
   ymx = (int) (y1 + _ma_ymax * (y2 - y1));
}

void XYGraph::flush (void) const
{
   // ativa canvas CD
   wdActivate(_cdcanvas);

   if (_cvimage)
   {
      XYGraph* g = (XYGraph*) this;

      // consulta posição do gráfico
      int x, y;
      g -> position(&x, &y);

      // consulta região ocupada pelo gráfico no canvas
      int x1, y1, x2, y2;
      g -> getViewport(x1, x2, y1, y2);

      // copia o pedaço da imagem que contém o gráfico para o canvas CD
      cdPutImageRect (_image, x, y, x1, x2, y1, y2);
      
      // OBS : Destroi o _cvimage a cada novo draw -> Nao eh muito eficiente
      // define o canvas da imagem como sendo nulo
      cdKillCanvas (_cvimage);
      g -> canvasImage(0);
   }
   // comentado para resolver o problema da impressao de varios
   // graficos num mesmo canvas. o cdflush faz pular de pagina.
   //else
   //   cdFlush();
}

XYMask& XYGraph::mask(unsigned m)
{
   XYMask *temp = NULL, *nothing = NULL;
   XYListIterator<XYMask> im(&_masks);

   for (unsigned i = 0; i < m-1; i++)
   {
      if (im.End())
      return *nothing;

      temp = im.Next();
   }

   return *temp;
}

void XYGraph::scroll (int dx, int dy)
{
   activateCanvas();

   int ua_x1, ua_y1, ua_x2, ua_y2;
   getMaskArea (ua_x1, ua_y1, ua_x2, ua_y2);

   // faz deslocamento da região selecionada
   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(ua_x1 + 1, ua_x2, ua_y1, ua_y2);
        
   cdScrollImage(ua_x1, ua_x2, ua_y1, ua_y2, -dx, -dy);

   // limpa região horizontal não deslocada
   if (dy != 0)
   {
      cdForeground(CD_WHITE);
      cdInteriorStyle(CD_SOLID);

      if (dy > 0)
      {
         cdClipArea(ua_x1, ua_x2, ua_y2 - dy, ua_y2);   
         cdBox(ua_x1, ua_x2, ua_y2 - dy, ua_y2);
         drawMaskArea(ua_x1, ua_y2 - dy, ua_x2, ua_y2);
      }
      else
      {
         cdClipArea(ua_x1, ua_x2, ua_y1, ua_y1 - dy);   
         cdBox(ua_x1, ua_x2, ua_y1, ua_y1 - dy);
         drawMaskArea(ua_x1, ua_y1, ua_x2, ua_y1 - dy);
      }
   }

   // limpa região vertical não deslocada
   if (dx != 0)
   {
      cdForeground(CD_WHITE);
      cdInteriorStyle(CD_SOLID);

      if (dx > 0)
      {
         cdClipArea(ua_x2 - dx, ua_x2, ua_y1, ua_y2);
         cdBox(ua_x2 - dx, ua_x2, ua_y1, ua_y2);
         drawMaskArea (ua_x2 - dx, ua_y1, ua_x2, ua_y2);
      }
      else
      {
         cdClipArea(ua_x1, ua_x1 - dx + 1, ua_y1, ua_y2);
         cdBox(ua_x1, ua_x1 - dx + 1, ua_y1, ua_y2);
         drawMaskArea (ua_x1, ua_y1, ua_x1 - dx + 1, ua_y2);
      }
   }

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

xybool XYGraph::contains(const XYObject* obj)
{
   // testa lista de marcadores
   XYListIterator<XYMarker> imk(&_markers);
   if (imk.Contains((XYMarker*)obj) == xytrue)
     return xytrue;        

   // testa lista de máscaras
   XYListIterator<XYMask> im(&_masks);
   if (im.Contains((XYMask*)obj) == xytrue)
     return xytrue;

   // testa lista de "slices"
   XYListIterator<XYSlice> is(&_slices);
   if (is.Contains((XYSlice*)obj) == xytrue)
     return xytrue;
    
   // testa lista de "areas"
   XYListIterator<XYArea> ia(&_areas);
   if (ia.Contains((XYArea*)obj) == xytrue)
     return xytrue;
    
   // testa lista de "decoradores"
   XYListIterator<XYObject> id(&_decorators);
   if (id.Contains((XYObject*)obj) == xytrue)
     return xytrue;
    
   // testa legenda, se houver
   if (_legend)
      // se objeto é uma legenda...
      if (_legend == obj)
         return xytrue;

   // testa lista de textos
   XYListIterator<XYText> it(&_titles);
   if (it.Contains((XYText*)obj) == xytrue)
     return xytrue;
      
   // testa lista de eixos
   XYListIterator<XYAxis> in(&_axes);
   if (in.Contains((XYAxis*)obj) == xytrue)
     return xytrue;
    
   return xyfalse;
}

XYObject* XYGraph::pick (int px, int py)
{
   activateCanvas();

   // testa lista de marcadores
   XYListIterator<XYMarker> ic(&_markers);
   XYMarker* kcont;

   while (!ic.End())
   {
      kcont = ic.Next();

      // decide pick
      if (kcont -> pick(px, py))
         return kcont;
   }

   // testa lista de máscaras
   XYListIterator<XYMask> im(&_masks);
   XYMask *mcont, *sel=NULL;

   while (!im.End())
   {
      mcont = im.Next();

      // decide pick
      if (mcont -> pick(px, py))
       sel = mcont;
   }
   if (sel!=NULL) return sel;

   // define window para [0.0, 1.0] x [0.0, 1.0]
   setWindow();
   setViewport();

   // antes de testar "slices" para pick é necessário inverter a ordem
   // na lista que os contém porque eles foram inseridos no final dela
   // e isso faz com que sejam desenhados na ordem correta mas o pick
   // precisa pesquisar na ordem inversa

   XYListIterator<XYSlice> iu(&_aux_slices);  // lista auxiliar de "slices"
   XYListIterator<XYSlice> is(&_slices);      // lista original de "slices"
   XYSlice* xcont;
   XYSlice* scont;

   // limpa lista auxiliar caso ela possua algum elemento
   while (!iu.End())
   {
      xcont = iu.Next();
      _aux_slices.remove(xcont);
   }

   // inverte ordem da lista original numa lista auxiliar
   while (!is.End())
   {
      scont = is.Next();
      _aux_slices.insert(scont);
   }

   iu.Reset();

   // testa lista invertida de "slices" para pick
   while (!iu.End())
   {
      scont = iu.Next();

      // decide pick
      if (scont -> pick(px, py))
         return scont;
   }

   // testa legenda para pick, se houver
   if (_legend)
      if (_legend -> pick(px, py))
         return _legend;

   // testa lista de textos
   XYListIterator<XYText> it(&_titles);
   XYText* tcont;

   while (!it.End())
   {
      tcont = it.Next();

      // decide pick
      if (tcont -> pick(px, py))
         return tcont;
   }

   // testa lista de eixos
   XYListIterator<XYAxis> in(&_axes);
   XYAxis* acont;

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

      // decide pick
      if (acont -> pick(px, py))
         return acont;
   }

   return NULL;
}

XYAxis* XYGraph::pickAxis (int x, int y)
{
   activateCanvas();

   // testa lista de eixos
   XYListIterator<XYAxis> in(&_axes);
   XYAxis* cont;

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

      // decide pick
      if (cont -> pick(x, y))
         return cont;
   }

   return 0;
}

XYArea* XYGraph::pickArea (int x, int y)
{
   activateCanvas();

   XYListIterator<XYArea> is(&_areas); 
   XYArea* acont;

   while (!is.End())
   { acont = is.Next();
     if (acont->pick(x, y)) return acont;
   }

   return 0;
}

XYSlice* XYGraph::pickSlice (int x, int y)
{
   activateCanvas();

   // antes de testar "slices" para pick é necessário inverter a ordem
   // na lista que os contém porque eles foram inseridos no final dela
   // e isso faz com que sejam desenhados na ordem correta mas o pick
   // precisa pesquisar na ordem inversa

   XYListIterator<XYSlice> iu(&_aux_slices);  // lista auxiliar de "slices"
   XYListIterator<XYSlice> is(&_slices);      // lista original de "slices"
   XYSlice* xcont;
   XYSlice* scont;

   // limpa lista auxiliar caso ela possua algum elemento
   while (!iu.End())
   {
      xcont = iu.Next();
      _aux_slices.remove(xcont);
   }

   // inverte ordem da lista original na lista auxiliar
   while (!is.End())
   {
      scont = is.Next();
      _aux_slices.insert(scont);
   }

   iu.Reset();

   // testa lista invertida de "slices" para pick
   while (!iu.End())
   {
      scont = iu.Next();

      // decide pick
      if (scont -> pick(x, y))
         return scont;
   }

   return 0;
}

XYMarker* XYGraph::pickMarker (int x, int y)
{
   activateCanvas();

   // testa lista de marcadores
   XYListIterator<XYMarker> ic(&_markers);
   XYMarker* cont;

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

      // decide pick
      if (cont -> pick(x, y))
         return cont;
   }

   return 0;
}

XYMask* XYGraph::pickMask (int x, int y)
{
   activateCanvas();

   // testa lista de máscaras
   XYListIterator<XYMask> im(&_masks);
   XYMask *cont, *sel=NULL;

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

      // decide pick
      if (cont -> pick(x, y))
       sel = cont;
   }

   return sel;
}

XYLegend* XYGraph::pickLegend (int x, int y)
{
   activateCanvas();

   // decide pick para a legenda
   if (_legend)
      if (_legend -> pick(x, y))
         return _legend;

   return 0;
}

XYText* XYGraph::pickText (int x, int y)
{
   activateCanvas();

   // testa lista de textos
   XYListIterator<XYText> it(&_titles);
   XYText* cont;

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

      // decide pick
      if (cont -> pick(x, y))
         return cont;
   }

   return 0;
}

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

   XYList<XYObject>* obj = new XYList<XYObject>;

   // verifica lista de marcadores para "fence"
   XYListIterator<XYMarker> ic(&_markers);
   XYMarker* kcont;

   while (!ic.End())
   {
      kcont = ic.Next();

      // decide "fence"
      if (kcont -> fence(x0, y0, x1, y1))
         obj -> insert(kcont);
   }

   // verifica lista de máscaras para "fence"
   XYListIterator<XYMask> im(&_masks);
   XYMask* mcont;

   while (!im.End())
   {
      mcont = im.Next();

      // decide "fence"
      if (mcont -> fence(x0, y0, x1, y1))
         obj -> insert(mcont);
   }

   // define window para [0.0, 1.0] x [0.0, 1.0]
   setWindow();
   setViewport();

   // verifica lista de "slices" para "fence"
   XYListIterator<XYSlice> is(&_slices);
   XYSlice* scont;

   while (!is.End())
   {
      scont = is.Next();

      // decide "fence"
      if (scont -> fence(x0, y0, x1, y1))
         obj -> insert(scont);
   }

   // verifica lista de "areas" para "fence"
   XYListIterator<XYArea> ir(&_areas);
   XYArea* rcont;
   while (!ir.End())
   { rcont = ir.Next();
     if (rcont->fence(x0, y0, x1, y1)) obj -> insert(rcont);
   }

   // testa lista de eixos para "fence"
   XYListIterator<XYAxis> in(&_axes);
   XYAxis* acont;

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

      // decide "fence"
      if (acont -> fence(x0, y0, x1, y1))
         obj -> insert(acont);
   }

   // verifica lista de textos para "fence"
   XYListIterator<XYText> it(&_titles);
   XYText* tcont;

   while (!it.End())
   {
      tcont = it.Next();

      // decide "fence"
      if (tcont -> fence(x0, y0, x1, y1))
         obj -> insert(tcont);
   }

   // testa legenda para "fence", se houver
   if (_legend)
      if (_legend -> fence(x0, y0, x1, y1))
         obj -> insert(_legend);

   return obj;
}

void XYGraph::print (void)
{
   cdCanvas *oldcanvas = _cdcanvas;
   _cdcanvas = cdCreateCanvas (CD_PS, (void *) "imagem");

   draw();
   cdKillCanvas (_cdcanvas);
   _cdcanvas = oldcanvas;
   activateCanvas();
}

void XYGraph::clear (void)
{
   activateCanvas();
   defineViewport();

   int mode = cdClip(CD_CLIPOFF);

   // preenche o fundo da região do gráfico com a cor definida pelo usuário
   cdForeground(_color);
   cdInteriorStyle(CD_SOLID);

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

   cdClip(mode);
}

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

   // preenche o fundo da região do gráfico com a cor definida pelo usuário
   cdForeground(_color);
   cdInteriorStyle(CD_SOLID);

   cdBox(xmin, xmax, ymin, ymax);

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

void XYGraph::maskAreaClear (void) const
{
   int x1, y1, x2, y2;
   getMaskArea(x1, y1, x2, y2);

   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(x1, x2, y1, y2);

   // preenche a região de desenho das máscaras do gráfico com a cor
   // definida pelo usuário
   cdForeground(_ma_color);
   cdInteriorStyle(CD_SOLID);

   cdBox(x1, x2, y1, y2);

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

void XYGraph::propagateViewport (void) const
{
   int x1, y1, x2, y2;
   getViewport(x1, x2, y1, y2);

   XYListIterator<XYText> it(&_titles);
   XYText* tcont;

   // define área no gráfico para todos os textos
   while (!it.End())
   {
      tcont = it.Next();
      tcont -> setViewport(x1, x2, y1, y2);
   }

   XYListIterator<XYAxis> in(&_axes);
   XYAxis* acont;

   // define área no gráfico para todos os eixos
   while (!in.End())
   {
      acont = in.Next();
      acont -> setViewport(x1, x2, y1, y2);
   }

   XYListIterator<XYSlice> is(&_slices);
   XYMarker* bcont;
   XYMarker* fcont;
   XYSlice* scont;
   const XYAxis* ncont;

   int sx1, sx2, sy1, sy2;
   getMaskArea(sx1, sy1, sx2, sy2);

   // define área no gráfico para todos os "slices"
   while (!is.End())
   {
      scont = is.Next();
      scont -> setViewport(sx1, sx2, sy1, sy2);

      ncont = scont -> axis();
        
      bcont = scont -> beginMarker();
      bcont -> setViewport(sx1, sx2, sy1, sy2);
        
      fcont = scont -> endMarker();
      fcont -> setViewport(sx1, sx2, sy1, sy2);

      if (ncont -> rotation() == 0.0)
            {
         bcont -> limit(_ma_ymax - _ma_ymin);
         fcont -> limit(_ma_ymax - _ma_ymin);
            }
      else
            {
         bcont -> limit(_ma_xmax - _ma_xmin);
         fcont -> limit(_ma_xmax - _ma_xmin);
            }
   }

   XYListIterator<XYMarker> ic(&_markers);
   XYMarker* ccont;

   // define área no gráfico para todos os marcadores
   while (!ic.End())
   {
      ccont = ic.Next();
      ccont -> setViewport(sx1, sx2, sy1, sy2);

      ncont = ccont -> axis();

      if (ncont -> rotation() == 0.0)
         ccont -> limit(_ma_ymax - _ma_ymin);
      else
         ccont -> limit(_ma_xmax - _ma_xmin);
   }

   XYListIterator<XYMask> im(&_masks);

   if (!im.End())
   {
      XYMask* cont;

      // define área no gráfico para todas as máscaras
      while (!im.End())
      {
         cont = im.Next();
         cont -> setViewport(sx1, sx2 - 1, sy1 + 1, sy2);
      }
   }

   // define área no gráfico para legenda
   if (_legend != NULL)
      _legend -> setViewport(x1, x2, y1, y2);
}

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

   activateCanvas();

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

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

void XYGraph::draw (int xmin, int ymin, int xmax, int ymax) const
{
   if (visible() == xyfalse) return;

   activateCanvas();

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

   // desenha lista de decorators
   XYListIterator<XYObject> id(&_decorators);
   XYObject* dcont;

   while (!id.End())
   {
      dcont = id.Next();
      dcont -> draw(xmin, ymin, xmax, ymax);
   }

   // desenha lista de textos
   XYListIterator<XYText> it(&_titles);
   XYText* tcont;

   while (!it.End())
   {
      tcont = it.Next();
      tcont -> draw(xmin, ymin, xmax, ymax);
   }

   // desenha lista de eixos
   XYListIterator<XYAxis> in(&_axes);
   XYAxis* acont;

   while (!in.End())
   {
      acont = in.Next();
      acont -> draw(xmin, ymin, xmax, ymax);
   }

   // desenha todas as máscaras
   XYListIterator<XYMask> im(&_masks);
   XYMask* mcont;

   while (!im.End())
   {
      mcont = im.Next();
      mcont -> draw(xmin, ymin, xmax, ymax);
   }

   // redefine window e viewport porque as máscaras possuem transformações
   // próprias
   setWindow();
   setViewport();

   im.Reset();

   // desenha todos os marcadores
   XYListIterator<XYMarker> ic(&_markers);
   XYMarker* ccont;
   while (!ic.End())
   { ccont = ic.Next();
     ccont->draw(xmin, ymin, xmax, ymax);
   }


   // desenha legenda para as máscaras, se existir
   if (_legend != NULL) _legend -> draw(xmin, ymin, xmax, ymax);

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

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

   XYListIterator<XYAxis> in(&_axes);
   XYAxis* acont;

   double x1, y1, x2, y2;
   double rot_rad;

   // desenha eixo com linha sólida mais fina possível e com cor definida
   // pelo usuário, se ele estiver dentro da área útil
   while (!in.End())
   {
      acont = in.Next();

      // consulta posição do eixo
      acont -> position(&x1, &y1);

      // ângulo de rotação em radianos
      rot_rad = acont -> rotation() * XY_PI / 180.0;

      // (x2, y2) ponto superior direito no eixo
      x2 = x1 + acont -> size() * cos (rot_rad);
      y2 = y1 + acont -> size() * sin (rot_rad);

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

      if ((x1 >= _ma_xmin) && (y1 >= _ma_ymin) && (x2 <= _ma_xmax)
          && (y2 <= _ma_ymax))
         // desenha eixo
         acont -> draw();
   }

   // desenha todas as máscaras
   XYListIterator<XYMask> im(&_masks);
   XYMask* cont;

   while (!im.End())
   {
      cont = im.Next();
      cont -> draw(xmin, ymin, xmax, ymax);
   }

   // redefine window e viewport porque as máscaras possuem transformações
   // próprias
   setWindow();
   setViewport();

   // desenha todos os marcadores
   XYListIterator<XYMarker> ic(&_markers);
   XYMarker* ccont;
   while (!ic.End())
   { ccont = ic.Next();
     ccont -> draw(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