---

xypos.cpp

Go to the documentation of this file.

/*****************************************************************************/
/* Módulo: xypos.cpp                                                         */
/* Autores: Carlos Henrique Levy e Jaudênia Cavalcante                       */
/* Modificacao: Paulo Mattos                                                 */
/* Data: 15 mar 96                                                           */
/* Comentário:                                                               */
/*    Implementação de métodos da classe que define a posição de um objeto   */
/* de forma absoluta ou de forma relativa a um outro objeto.                 */
/*****************************************************************************/

#include <stdlib.h>

#include "cd.h"
#include "wd.h"
#include "xyobj.h"
#include "xypos.h"

const char* xy_id_xypos_cpp="$Id: xypos.cpp,v 1.14 1999/07/14 13:04:11 camilo Exp $";
                                                                
void XYPosition::set (XYCoordinate x, XYCoordinate y)
{
   *_x = x;
   *_y = y;
}

void XYPosition::getX (int* xr, const XYObject* org) const
{
   // consulta a região de desenho do objeto corrente   
   int x1, x2, y1, y2;
   if (org)
     org -> getViewport(x1, x2, y1, y2);

   double x, y;

   switch (_x ->type())
   {
      case XYCoordinate::pixel:
               // define a posição do objeto em pixel
               _x -> get(xr);

               return;

      case XYCoordinate::world:
               // define a posição do objeto entre [0.0, 1.0]
               _x -> get(&x);
         if (org)
           *xr = x1 + (int) (x * (x2 - x1));

               return;

      default:
         if (_x -> reference() == 0)
               {
                *xr = 0;
                  return;
               }

               const XYObject* ref = _x -> reference();

               // consulta posição do objeto de referência
               ref -> position(&x, &y);

               int dir = _x -> direction();

         if (x && (dir == XYCoordinate::left || dir == XYCoordinate::right))
         {
                  XYPosition* t = (XYPosition *) this;

                  // consulta menor retângulo que envolve o objeto de referência
                  int bx1, bx2, by1, by2;
            ref -> boundingBox (bx1, by1, bx2, by2);

                  // guarda tipo corrente de coordenada
                  int oldtype = _x -> type();

                  // define tipo de coordenada como sendo pixel para evitar
                  // recursão no cálculo do boundingBox do objeto corrente
                  t -> _x -> type(XYCoordinate::pixel); 

                  // define origem como posição para o tipo pixel definido
                  t -> _x -> set(0);

                  // calcula o menor retângulo que envolve o objeto corrente
            int obx1, obx2, oby1, oby2;
                  org -> boundingBox (obx1, oby1, obx2, oby2);

                  // restaura tipo de coordenada para o objeto corrente
                  t -> _x -> type(oldtype);

                  // define valor da coordenada se posição for a esquerda
                  if (dir == XYCoordinate::left)
               *xr = bx1 - _x -> gap() - obx2;
                  else // se posição for a direita
               *xr = bx2 + _x -> gap() - (obx1 - 1);
                
                  return;
            }
   }
}

void XYPosition::getX (double* xr, const XYObject* org) const
{
   org -> setWindow();

   // consulta a região de desenho do objeto corrente   
   int x1, x2, y1, y2;
   if (org)
     org -> getViewport(x1, x2, y1, y2);

   int x, y;

   switch (_x -> type())
   {
      case XYCoordinate::pixel:
               // define a posição do objeto em pixel
               _x -> get(&x);
         if (org) // nao ha como converter !
           *xr = ((double)(x - x1) / (double)(x2 - x1));

               return;

      case XYCoordinate::world:
               // define a posição do objeto entre [0.0, 1.0]
               _x -> get(xr);

               return;

      default:
         if (_x -> reference() == 0)
               {
                *xr = 0.0;
                  return;
               }

               const XYObject* ref = _x -> reference();

               // consulta posição do objeto de referência
               ref -> position(&x, &y);

               int dir = _x -> direction();

         if (x && (dir == XYCoordinate::left || dir == XYCoordinate::right))
         {
                  XYPosition* t = (XYPosition *) this;

                  // consulta menor retângulo que envolve o objeto de referência
                  int bx1, bx2, by1, by2;
            ref -> boundingBox (bx1, by1, bx2, by2);

                  // guarda tipo corrente de coordenada
                  int oldtype = _x -> type();

                  // define tipo de coordenada como sendo pixel para evitar
                  // recursão no cálculo do boundingBox do objeto corrente
                  t -> _x -> type(XYCoordinate::pixel); 

                  // define origem como posição para o tipo pixel definido
                  t -> _x -> set(0);

                  // calcula o menor retângulo que envolve o objeto corrente
            int obx1, obx2, oby1, oby2;
                  org -> boundingBox (obx1, oby1, obx2, oby2);

                  // restaura tipo de coordenada para o objeto corrente
                  t -> _x -> type(oldtype);

                  // define valor da coordenada se posição for a esquerda
                  if (dir == XYCoordinate::left)
               *xr = ((double) ((bx1 - _x -> gap() - obx2) - x1)
                   / (double)(x2 - x1));
                  else // se posição for a direita
               *xr = ((double) ((bx2 + _x -> gap() - (obx1 - 1)) - x1)
                   / (double)(x2 - x1));
                
                  return;
            }
   }
}

void XYPosition::getX (XYCoordinate*) const
{
}

void XYPosition::getY (int* yr, const XYObject* org) const
{
   org -> setWindow();

   // consulta a região de desenho do objeto corrente   
   int x1, x2, y1, y2;
   if (org)
     org -> getViewport(x1, x2, y1, y2);

   double x, y;

   switch (_y -> type())
   {
      case XYCoordinate::pixel:
               // define a posição do objeto em pixel
               _y -> get(yr);

               return;

      case XYCoordinate::world:
         // define a posição do objeto entre [0.0, 1.0]
               _y -> get(&y);
         if (org)
           *yr = y1 + (int) (y * (y2 - y1));

               return;

      default:
         if (_y -> reference() == 0)
               {
                *yr = 0;
                  return;
               }

               const XYObject* ref = _y -> reference();

               // consulta posição do objeto de referência
               ref -> position(&x, &y);

               int dir = _y -> direction();

         if (y && (dir == XYCoordinate::bottom || dir == XYCoordinate::top))
         {
                  XYPosition* t = (XYPosition *) this;

                  // consulta menor retângulo que envolve o objeto de referência
                  int bx1, bx2, by1, by2;
            ref -> boundingBox (bx1, by1, bx2, by2);

                  // guarda tipo corrente de coordenada
                  int oldtype = _y -> type();

                  // define tipo de coordenada como sendo pixel para evitar
                  // recursão no cálculo do boundingBox do objeto corrente
                  t -> _y -> type(XYCoordinate::pixel); 

                  // define origem como posição para o tipo pixel definido
                  t -> _y -> set(0);

                  // calcula o menor retângulo que envolve o objeto corrente
            int obx1, obx2, oby1, oby2;
                  org -> boundingBox (obx1, oby1, obx2, oby2);

                  // restaura tipo de coordenada para o objeto corrente
                  t -> _y -> type(oldtype);

                  // define valor da coordenada se posição for abaixo
                  if (dir == XYCoordinate::bottom)
               *yr = by1 - _y -> gap() - oby2;
                  else // se posição for acima
               *yr = by2 + _y -> gap() - (oby1 - 1);
                
                  return;
            }
   }
}

void XYPosition::getY (double* yr, const XYObject* org) const
{
   // consulta a região de desenho do objeto corrente   
   int x1, x2, y1, y2;
   if (org)
     org -> getViewport(x1, x2, y1, y2);

   int x, y;
   switch (_y -> type())
   {
      case XYCoordinate::pixel:
               // define a posição do objeto em pixel
               _y -> get(&y);
         if (org)
           *yr = ((double)(y - y1) / (double)(y2 - y1));

               return;

      case XYCoordinate::world:
               // define a posição do objeto entre [0.0, 1.0]
               _y -> get(yr);

               return;

      default:
         if (_y -> reference() == 0)
               {
                *yr = 0.0;
                  return;
               }

               const XYObject* ref = _y -> reference();

               // consulta posição do objeto de referência
               ref -> position(&x, &y);

               int dir = _y -> direction();

         if (y && (dir == XYCoordinate::bottom || dir == XYCoordinate::top))
         {
                  XYPosition* t = (XYPosition *) this;

                  // consulta menor retângulo que envolve o objeto de referência
                  int bx1, bx2, by1, by2;
            ref -> boundingBox (bx1, by1, bx2, by2);

                  // guarda tipo corrente de coordenada
                  int oldtype = _y -> type();

                  // define tipo de coordenada como sendo pixel para evitar
                  // recursão no cálculo do boundingBox do objeto corrente
                  t -> _y -> type(XYCoordinate::pixel); 

                  // define origem como posição para o tipo pixel definido
                  t -> _y -> set(0);

                  // calcula o menor retângulo que envolve o objeto corrente
            int obx1, obx2, oby1, oby2;
                  org -> boundingBox (obx1, oby1, obx2, oby2);

                  // restaura tipo de coordenada para o objeto corrente
                  t -> _y -> type(oldtype);

                  // define valor da coordenada se posição for abaixo
                  if (dir == XYCoordinate::bottom)
               *yr = ((double) ((by1 - _y -> gap() - oby2) - y1)
                   / (double)(y2 - y1));
                  else // se posição for acima
               *yr = ((double) ((by2 + _y -> gap() - (oby1 - 1)) - y1)
                   / (double)(y2 - y1));
                
                  return;
            }
   }
}

void XYPosition::getY (XYCoordinate*) const
{
}

---

XY
Tecgraf / PUC-Rio - Computer Graphics Technology Group