---

xyarca.cpp

Go to the documentation of this file.

/*****************************************************************************/
/* Módulo: xyarca.cpp                                                        */
/* Comentário:                                                               */
/*****************************************************************************/

#include "xyarca.h"

const char* xy_id_xyarca_cpp="$Id: xyarca.cpp,v 1.4 2002/06/04 20:01:32 clinio Exp $";
                                                                
XYCartesianArea::XYCartesianArea(
      const XYAxis* axis1, const XYAxis* axis2,
      double begin1, double end1,
      double begin2, double end2, xybool visible) : 
      XYArea(axis1, axis2, begin1, end1, begin2, end2, visible)
{
}

XYCartesianArea::~XYCartesianArea (void)
{
}

xybool XYCartesianArea::pick (int px, int py)
{
   if (visible() == xyfalse)    return xyfalse;

   // limites da menor caixa que contém um "slice"
   int x1, y1, x2, y2;
   boundingBox(x1, y1, x2, y2);

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

xybool XYCartesianArea::fence (int x2, int y2, int x3, int y3)
{
   if (visible() == xyfalse) return xyfalse;

   // limites da menor caixa que contém um "slice"
   int x0, y0, x1, y1;
   boundingBox (x0, y0, x1, y1);

   return mtInclude (x0, y0, x1, y1, x2, y2, x3, y3);
}

void XYCartesianArea::draw (void)
{
   int xmin, ymin, xmax, ymax;

   // consulta área do gráfico
   getViewport (xmin, xmax, ymin, ymax);
   draw(xmin, ymin, xmax, ymax);
}

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

   int vpxmin, vpxmax, vpymin, vpymax;
   getViewport(vpxmin, vpxmax, vpymin, vpymax);

   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
   int clipxmin, clipymin, clipxmax, clipymax;
   getClip(clipxmin, clipymin, clipxmax, clipymax);
   cdClipArea(clipxmin, clipxmax, clipymin, clipymax);

   // pinta o fundo da região com a cor dada pelo usuário
   cdForeground (backgroundColor());
   cdInteriorStyle(CD_SOLID);

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

   // Evitar estouro de representacao de inteiros para casos
   // onde ha grande diferenca entre a area e as escalas...
   x1 = x1 < clipxmin ? clipxmin-10 : x1;
   x2 = x2 < clipxmin ? clipxmin-10 : x2;
   x1 = x1 > clipxmax ? clipxmax+10 : x1;
   x2 = x2 > clipxmax ? clipxmax+10 : x2;

   y1 = y1 < clipymin ? clipymin-10 : y1;
   y2 = y2 < clipymin ? clipymin-10 : y2;
   y1 = y1 > clipymax ? clipymax+10 : y1;
   y2 = y2 > clipymax ? clipymax+10 : y2;

   cdBox(x1, x2, y1, y2);

   cdLineStyle(style());
   cdLineWidth(width());      
   cdForeground(color());
   cdRect(x1, x2, y1, y2);

   int old_alg = cdTextAlignment( CD_CENTER );
   double old_or = cdTextOrientation( 0.0 );
   int tw, th;
   cdTextSize( _text, &tw, &th );

   if ( fabs(x2-x1) < fabs(y2-y1) ) {
      cdTextOrientation( 90.0 );
      int trash = th;
      th = tw;
      tw = trash;
   }
   cdForeground(_textColor);
   cdFont(CD_HELVETICA, CD_BOLD, _textSize);

   if ( ( tw < fabs(x2-x1) && th < fabs(y2-y1) ) || _forced_text ) {
     cdText( (x1+x2)/2, (y1+y2)/2, _text );
   }

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

void XYCartesianArea::getClip(int &xmin, int &ymin, 
      int &xmax, int &ymax) const
{
   if (visible() == xyfalse) return;

   int trash;
   int lxmin, lxmax, lymin, lymax;
   pixelAt( _axis1, _axis1->min(), lxmin, trash );
   pixelAt( _axis1, _axis1->max(), lxmax, trash );
   pixelAt( _axis2, _axis2->min(), trash, lymin );
   pixelAt( _axis2, _axis2->max(), trash, lymax );

   int x1, x2, x3, x4;
   int y1, y2, y3, y4;
   pixelAt( _axis1, _begin1, x1, y1 );
   pixelAt( _axis1, _end1, x2, y2 );
   pixelAt( _axis2, _begin2, x3, y3 );
   pixelAt( _axis2, _end2, x4, y4 );

   xmin = MAX( x1, lxmin )-_width;
   ymin = MAX( y3, lymin )-_width;
   xmax = MIN( x2, lxmax )+_width;
   ymax = MIN( y4, lymax )+_width;
}

void XYCartesianArea::boundingBox(int &xmin, int &ymin, 
      int &xmax, int &ymax) const
{
   if (visible() == xyfalse) return;

   int trash;
   int lxmin, lxmax, lymin, lymax;
   pixelAt( _axis1, _axis1->min(), lxmin, trash );
   pixelAt( _axis1, _axis1->max(), lxmax, trash );
   pixelAt( _axis2, _axis2->min(), trash, lymin );
   pixelAt( _axis2, _axis2->max(), trash, lymax );

   int x1, x2, x3, x4;
   int y1, y2, y3, y4;
   pixelAt( _axis1, _begin1, x1, y1 );
   pixelAt( _axis1, _end1, x2, y2 );
   pixelAt( _axis2, _begin2, x3, y3 );
   pixelAt( _axis2, _end2, x4, y4 );

   xmin = x1;
   ymin = y3;
   xmax = x2;
   ymax = y4;
}

void XYCartesianArea::pixelAt( const XYAxis* acont, 
      double value, int& px, int& py ) const
{
  if (acont)
  {
     acont->pointInValue( value, px, py );
  }
}

---

XY
Tecgraf / PUC-Rio - Computer Graphics Technology Group