---

xygraca.cpp

Go to the documentation of this file.

/*****************************************************************************/
/* Módulo: xygraca.cpp                                                        */
/* Autores: Carlos Henrique Levy e Jaudênia Cavalcante                       */
/* Data: 26 fev 96                                                           */
/* Comentário:                                                               */
/*    Implementação de métodos da classe especializada responsável pelo dese */
/* nho de gráficos do tipo cartesiano que tem como principal característica  */
/* pelo menos dois eixos, um na direção x (rotação 0) e outro na direção y   */
/* (rotação 90).                                                             */
/*****************************************************************************/

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

#include "xygraca.h"
#include "xymkca.h"

const char* xy_id_xycart_cpp="$Id: xygraca.cpp,v 1.26 2002/01/23 16:12:20 clinio Exp $";
                                                                
#ifndef NOIUP
XYCartesian::XYCartesian (Ihandle* canvas,
                          XYCoordinate x,
                          XYCoordinate y,
                          double width,
                          double height,
                                XYGrid* gridh,
                                          XYGrid* gridv,
                                          xybool visible)
                                          : XYGraph(canvas, x, y, width, height,
                                                    visible),
                                            _gridh(gridh),
                                            _gridv(gridv)
{
}
#endif

XYCartesian::XYCartesian (cdCanvas* cdcanvas,
                          XYCoordinate x,
                          XYCoordinate y,
                          double width,
                          double height,
                                          XYGrid* gridh,
                                          XYGrid* gridv,
                                          xybool visible)
                                          : XYGraph(cdcanvas, x, y, width, height,
                                                    visible),
                                            _gridh(gridh),
                                            _gridv(gridv)
{
}
 
XYCartesian::~XYCartesian (void)
{
   // liberar grides alocados
}

void XYCartesian::setGridH (XYGrid *gridh)
{
   _gridh = gridh;
}

XYGrid* XYCartesian::getGridH (void) const
{
   return _gridh;
}

void XYCartesian::setGridV (XYGrid *gridv)
{
   _gridv = gridv;
}

XYGrid* XYCartesian::getGridV (void) const
{
   return _gridv;
}

XYObject* XYCartesian::markerCreate(int x0, int y0, const XYAxis* master)
{
   XYCartesianMarker* marker = NULL;

   // consulta eixo de referência para a criação de um marcador
   if (master != NULL)
   {
      // define atributos do marcador a partir dos atributos do eixo
      double pos = master -> valueInPoint(x0, y0);
      long color = master -> color();

      // constrói novo marcador cartesiano
      marker = new XYCartesianMarker(master, pos, color, 2,
                                     XYObject::continuous);

            // define alcance do marcador a partir de sua posição sobre o eixo
            if (master -> rotation() == 0.0)
         marker -> limit(_ma_ymax - _ma_ymin);
            else
         marker -> limit(_ma_xmax - _ma_xmin);
   }

   // insere marcador criado na lista de marcadores do gráfico
   insert(marker);

   return (XYObject *) marker;
}

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

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

   if (obj != NULL) return obj;

   // testa grade horizontal
   if (_gridh != NULL)
      if (_gridh -> pick(px, py))       
         return _gridh;

   // testa grade vertical
   if (_gridv != NULL)
      if (_gridv -> pick(px, py))       
         return _gridv;

   return NULL;
}

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

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

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

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

   return obj;
}

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

   while (!in.End())
   {
      cont = in.Next();
      double x, y;

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

      // considera a rotação do eixo para calcular a região de desenho das
      // máscaras
      switch ((int) cont -> rotation())
      {
         case 0:   // eixo na horizontal - base
            if (x < _ma_xmin)
               _ma_xmin = x;

            if (x + size > _ma_xmax)
               _ma_xmax = x + size;

                  break;

         case 180: // eixo na horizontal - topo
            if (x > _ma_xmax)
               _ma_xmax = x;

            if (x - size < _ma_xmin)
               _ma_xmin = x - size;

                  break;

         case 90:  // eixo na vertical direita
            if (y < _ma_ymin)
               _ma_ymin = y;

            if (y + size > _ma_ymax)
               _ma_ymax = y + size;

                  break;

               case 270: // eixo na vertical esquerda
            if (y > _ma_ymax)
               _ma_ymax = y;

            if (y - size < _ma_ymin)
               _ma_ymin = y - size;

                  break;
      }
   }
}

void XYCartesian::propagateViewport (void) const
{
   // define as áreas de desenho para todos os eixos e para todas as máscaras
   XYGraph::propagateViewport();

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

   if (_gridh)  // define área gráfica para a grade horizontal
   {
      _gridh -> position (_ma_xmin, _ma_ymin);
      _gridh -> size (_ma_xmax - _ma_xmin);
      _gridh -> limit (_ma_ymax - _ma_ymin);
      _gridh -> setViewport(x1, x2, y1, y2);
   }

   if (_gridv)  // define área gráfica para a grade vertical
   {
      _gridv -> position (_ma_xmin, _ma_ymin);
      _gridv -> size (_ma_ymax - _ma_ymin);
      _gridv -> limit (_ma_xmax - _ma_xmin);
      _gridv -> setViewport(x1, x2, y1, y2);
   }
}

void XYCartesian::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 XYCartesian::draw(int xmin, int ymin, int xmax, int ymax) const
{
   if (visible() == xyfalse)    // invisível!!!
      return;
    
   activateCanvas();
   propagateViewport();

   XYGraph::maskAreaClear();

   int oldmode = 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 todos os "slices"
   XYListIterator<XYSlice> is(&_slices);
   XYSlice* scont;
   while (!is.End())
   { scont = is.Next();
     scont -> draw(xmin, ymin, xmax, ymax);
   }

   // desenha todas as areas
   XYListIterator<XYArea> ir(&_areas);
   XYArea* rcont;
   while (!ir.End())
   { rcont = ir.Next();
     rcont->draw(xmin, ymin, xmax, ymax);
   }
   
   int x1, y1, x2, y2;
   getMaskArea (x1, y1, x2, y2);
   cdClipArea(x1, x2, y1, y2);
   // desenha grids 
   if (_gridh)  _gridh -> draw (xmin, ymin, xmax, ymax);
   if (_gridv)  _gridv -> draw (xmin, ymin, xmax, ymax);
   cdClipArea(xmin, xmax, ymin, ymax);

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

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

   if ( doubleBuffering()==xytrue ) XYGraph::flush();
}

void XYCartesian::drawMaskArea (void) const
{
   activateCanvas();
   propagateViewport();

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

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

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

   // desenha todos os "slices"
   XYListIterator<XYSlice> is(&_slices);
   XYSlice* scont;

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

   if (_gridh)  // desenha grade horizontal
      _gridh -> draw (xmin, ymin, xmax, ymax);

   if (_gridv)  // desenha grade vertical
      _gridv -> 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