---

xyleg.cpp

Go to the documentation of this file.

/*****************************************************************************/
/* Módulo: xyleg.cpp                                                         */
/* Autores: Carlos Henrique Levy e Jaudênia Cavalcante                       */
/* Data: 26 jun 96                                                           */
/* Comentário:                                                               */
/*    Implementação de métodos da classe que gerencia a apresentação da le-  */
/* genda para um determinado gráfico com o número de linhas e colunas defi-  */
/* nidos pelo usuário. Essa classe faz uso da mesma lista de máscaras válida */
/* para o gráfico ao qual ela está associada, medida que evita duplicação de */
/* informação. Seu layout é composto por uma região delimitada pela presença */
/* ou não de uma moldura, nomes das séries envolvidas e seus ícones de repre */
/* sentação.                                                                 */
/*****************************************************************************/

#include <stdlib.h>
#include "xyleg.h"

const char* xy_id_xyleg_cpp="$Id: xyleg.cpp,v 1.20 2000/06/13 13:46:12 camilo Exp $";
                                                                
#define AREA_MM 15        // dimensão da região para o ícone da legenda
#define SPACE_MM 4   // espaço para a legenda não colar em seu boundingBox
#define MARG  2   // espessura da moldura da legenda

XYLegend::XYLegend (XYCoordinate x,
                    XYCoordinate y,
                          int nlines,
                          int ncolumns,
                          xybool box,
                          xybool visible)
                          : XYObject(x, y, visible),
                            _nLines(nlines),
                            _nColumns(ncolumns),
                            _box(box),
                            _color(XY_WHITE),
                            _bColor(XY_BLACK)
{
}

XYLegend::~XYLegend (void)
{
}

void XYLegend::mask (const XYList<XYMask>* mask)
{
   _masks = mask;
}

const XYList<XYMask>* XYLegend::mask (void) const
{
   return _masks;
}

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

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

void XYLegend::frameColor (long color)
{
   _bColor = color;
}

long XYLegend::frameColor (void) const
{
   return _bColor;
}

void XYLegend::lines (int nl)
{
   _nLines = nl;
}

int XYLegend::lines (void) const
{
   return _nLines;
}

void XYLegend::columns (int nc)
{
   _nColumns = nc;
}

int XYLegend::columns (void) const
{
   return _nColumns;
}

void XYLegend::box (xybool b)
{
   _box = b;
}

xybool XYLegend::box (void) const
{
   return _box;
}

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

   // limites da menor caixa que contém uma legenda
   int x1, y1, x2, y2;
   boundingBox (x1, y1, x2, y2);

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

XYMask* XYLegend::pickItem (int px, int py)
{
   if (visible() == xyfalse)    // invisível!!!
      return NULL;

   XYListIterator<XYMask> im(_masks);
   XYMask* cont;

   int xmn, ymn, xmx, ymx;

   while (!im.End())
   {
            cont = im.Next();
      cont -> getItemViewport(xmn, xmx, ymn, ymx);

      if (mtPointInRect(px, py, xmn, ymn, xmx, ymx))
         return cont;
        }

   return NULL;
}

xybool XYLegend::fence (int x2, int y2, int x3, int y3)
{
   if (visible() == xyfalse)           // invisível!!!
      return xyfalse;

   // limites da menor caixa que contém uma legenda
   int x0, y0, x1, y1;
   boundingBox (x0, y0, x1, y1);

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

void XYLegend::clear(void) const
{
   // consulta região de desenho da legenda
   int xmn, ymn, xmx, ymx;
   getViewport(xmn, xmx, ymn, ymx);

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

   cdBox(xmn, xmx, ymn, ymx);
}

void XYLegend::clear(int xmin, int ymin, int xmax, int ymax) const
{
   // preenche o fundo da região da legenda com a cor definida pelo usuário
   cdForeground(backgroundColor());
   cdInteriorStyle(CD_SOLID);

   cdBox(xmin, xmax, ymin, ymax);
}

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

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

   // calcula a região ocupada pela legenda
   int txmin, tymin, txmax, tymax;
   boundingBox(txmin, tymin, txmax, tymax);

   // se o boundingBox é degenerado não existe legenda a desenhar
   if ((txmin == txmax) && (tymin == tymax))
      return;

   int spx;
   double smx;
   cdGetCanvasSize( &spx, NULL, &smx, NULL );
   double resx = spx / smx;
   int AREA = (int)(AREA_MM * resx);
   int SPACE = (int)(SPACE_MM * resx);

   if (_box)
   {
      // desenha a moldura da legenda
      cdForeground(frameColor());
      cdInteriorStyle(CD_SOLID);

      cdBox(txmin, txmax, tymin, tymax);
   }

   // limpa região interna a moldura para o desenho da legenda
   clear(txmin + MARG, tymin + MARG, txmax - MARG, tymax - MARG);

   // calcula espacamento entre as colunas e linhas 
   int dx = (int) (((txmax - txmin) - (2 * MARG)) / _nColumns);
   int dy = (int) (((tymax - tymin) - (2 * MARG)) / _nLines);

   int x = txmin + MARG + SPACE;
   int y = tymax - MARG - dy;

   XYListIterator<XYMask> im(_masks);

   XYMask* cont = 0;
   XYText* name;

   int bbx1, bby1, bbx2, bby2;

   // desenha a legenda do gráfico respeitando o número de linhas e colunas
   // definidos pelo usuário
   for (int i = 1; i <= _nLines; i++)
   {
      for (int j = 1; j <= _nColumns; j++)
      {
         if (!im.End())
         {
                name = NULL;

                // procura a próxima máscara com nome
            while ((name == NULL) && (!im.End()))
            {
                   cont = im.Next();
                   name = cont -> name();
                }

            if (name != NULL)
            {
                   // decide alinhamento
                   name -> align (XYText::southWest);

                   // decide posição para o nome
                   name -> position (x + AREA + SPACE, y);

                   // calcula o bounding box do nome da máscara
                   name -> boundingBox (bbx1, bby1, bbx2, bby2);

                   // desenha textos da legenda
                   name -> draw(x, y, bbx2, bby2);

                   cont -> setItemViewport(x, bbx2, y, bby2);

               // desenha o ícone da máscara na região dada, sem colar em suas
                   // bordas
                   cont -> drawIcon(x, y + SPACE, x + AREA, bby2 - SPACE);

                   // guarda o valor de x para o desenho do próximo nome
                           x += dx;
            }
         }
      }

          // valor inicial de x para a nova linha
      x = txmin + MARG + SPACE;         
      // valor inicial de y para a nova linha
      y -= dy;
   }
}

void XYLegend::boundingBox (int &bxmin, int &bymin, int &bxmax, int &bymax)
                                  const
{
   if (visible() == xyfalse)    // invisível!!!
      return;

   // consulta posição de desenho da legenda
   int xd, yd;
   position (&xd, &yd);

   // (bxmin, bymin) ponto inferior esquerdo da área da legenda
   bxmin = xd;
   bymin = yd;

   // (bxmax, bymax) ponto superior direito da área da legenda
   bxmax = bxmin;
   bymax = bymin;

   XYListIterator<XYMask> im(_masks);

   XYMask* cont;
   XYText* name = NULL;

   // verifica existência de máscara com nome
   while ((name == NULL) && (!im.End()))
   {
      cont = im.Next();
      name = cont -> name();
   }

   // se não existe nome de máscara não haverá legenda
   if (name == NULL)
      return;

   im.Reset();

   // consulta região de desenho da legenda
   int x1, x2, y1, y2;
   getViewport(x1, x2, y1, y2);

   // limpa conteúdo do ponteiro
   name = NULL;

   int bbx1, bbx2, bby1, bby2;

   // decide maior nome a ser colocado na legenda
   while (!im.End())
   {
      cont = im.Next();
      name = cont -> name();

      if (name != NULL)
      {
         // decide alinhamento
         name -> align (XYText::southWest);

         // decide região de desenho do nome
         name -> setViewport(x1, x2, y1, y2);

         // decide posição para o nome
         name -> position (xd, yd);

         // calcula o bounding box do nome da máscara
         name -> boundingBox (bbx1, bby1, bbx2, bby2);

         // atualiza maior valor de x encontrado
         if (bxmax < bbx2)
            bxmax = bbx2;

         // atualiza maior valor de y encontrado
         if (bymax < bby2)
            bymax = bby2;
      }
   }

   // atualizando valor máximo de x para o maior nome de máscara considerando
   // a região de desenho do ícone e do espaço entre ele e o nome
   int spx;
   double smx;
   cdGetCanvasSize( &spx, NULL, &smx, NULL );
   double resx = spx / smx;
   int AREA = (int)( AREA_MM * resx );
   int SPACE = (int)( SPACE_MM * resx );
   bxmax += AREA + 3 * SPACE;

   // calcula valor máximo total de x na legenda, somando-se ao valor máximo
   // de x do maior nome o número de colunas restantes vezes o intervalo em
   // x que esse nome ocupa
   bxmax += (_nColumns - 1) * (bxmax - bxmin);

   // calcula valor máximo total de y na legenda, somando-se ao valor máximo
   // de y do maior nome o número de linhas restantes vezes o intervalo em
   // y que esse nome ocupa
   bymax += (_nLines - 1) * (bymax - bymin);

   // acrescenta espaço para a moldura
   bxmax += 2 * MARG;
   bymax += 2 * MARG;
}

---

XY
Tecgraf / PUC-Rio - Computer Graphics Technology Group