---

xysddt.cpp

Go to the documentation of this file.

/*****************************************************************************/
/* Módulo: xysddt.cpp                                                        */
/* Autor: Camilo da Fonseca Freire                                           */
/* Data: 8 Ago 2000                                                          */
/* Comentário:                                                               */
/*    Implementação de métodos da classe especializada onde decorações de    */
/* datas, ou seja, a numeração é desenhada usando-se os valo-                */
/* res inicial e final dados no eixo ao qual está relacionada, seguindo a in */
/* crementação também indicada no formato definido pelo usuário.             */
/*****************************************************************************/

#include <time.h>

#include "xymath.h"
#include "xysddt.h"
#include "xyaxln.h"


#define FORMAT_STRING "  %02d/%02d/%04d  \n%02d:%02d:%02d"


const char* xy_id_xyscdtdt="$Id: xysddt.cpp,v 1.1 2003/01/03 16:08:53 clinio Exp $";
                                                                
XYDateScaleDecorator::XYDateScaleDecorator( XYText* scale ) : 
   _scale(scale)
{
   struct tm time1; 
   struct tm* new_time = NULL;
   time_t the_time1;
   time_t zero_timet = (time_t) 0;


   time1.tm_sec = 0; time1.tm_min = 0; time1.tm_hour = 0;
   time1.tm_mday = 1; time1.tm_mon = 1; time1.tm_year = 1970;

   time1.tm_isdst = 0;
   time1.tm_mon -= 1;
   time1.tm_year -= 1900;
   the_time1 = mktime( &time1 );
   _diff = the_time1;

   new_time = localtime( &zero_timet );
   if ( new_time->tm_isdst > 0 ) _diff -= 60 * 60;

   this->delta(0);
}

XYDateScaleDecorator::~XYDateScaleDecorator (void)
{
}

void XYDateScaleDecorator::scale (XYText* s)
{
   _scale = s;
}

XYText* XYDateScaleDecorator::scale (void) const
{
   return _scale;
}

void XYDateScaleDecorator::draw (const XYAxis *axis, int /* first_tick */,
                                      int /* last_tick */) const
{
   // intervalos de deslocamento em relação as direções x e y
   double dx, dy;
   double rot_rad = axis -> rotation() * XY_PI / 180.0;

   mtRotate ((axis -> step() * axis -> size()) / (axis -> max()
             - axis -> min()), 0.0, rot_rad, &dx, &dy);

   double ex1, ey1, ex2, ey2;
   axis -> firstTick (ex1, ey1, ex2, ey2);

   // consulta área do gráfico para o eixo
   int xmn, ymn, xmx, ymx;
   axis -> getViewport(xmn, xmx, ymn, ymx);

   // decide área no gráfico para a escala
   _scale -> setViewport(xmn, xmx, ymn, ymx);

   double tex2 = ex2;
   double tey2 = ey2;

   int ftx1, ftx2, fty1, fty2;
   int ltx1, ltx2, lty1, lty2;

   // calcula ticks que receberão labels para não haver sobreposição de labels,
   // o método é calcular boundindBox do maior label em ticks consecutivos e
   // verificar quando deixa de ocorrer sobreposição

   // consulta o boundingBox do primeiro texto na escala
   char c[80];
   struct tm *lt; 
   time_t tm = (int) axis -> first();
   tm += (time_t)_delta;

   lt = localtime(&tm);
   if ( lt->tm_isdst > 0 ) tm -= 60*60;

   lt = localtime(&tm);
   lt->tm_mon += 1;
   lt->tm_year += 1900;

   sprintf (c, FORMAT_STRING, 
         lt->tm_mday, lt->tm_mon, lt->tm_year,
         lt->tm_hour, lt->tm_min, lt->tm_sec );

   _scale -> text (c);
   _scale -> position (tex2, tey2);
   _scale -> boundingBox(ftx1, fty1, ftx2, fty2);

   // quantidade total de ticks
   int total = (int) floor ((axis -> max() - axis -> first()) / axis -> step());

   // consulta o boundingBox do último texto na escala
   tm = (int) axis -> max();
   tm += (time_t)_delta;
   lt = localtime(&tm);
   if ( lt->tm_isdst > 0 ) tm -= 60*60;

   lt = localtime(&tm);
   lt->tm_mon += 1;
   lt->tm_year += 1900;
   sprintf (c, FORMAT_STRING, 
         lt->tm_mday, lt->tm_mon, lt->tm_year,
         lt->tm_hour, lt->tm_min, lt->tm_sec );

   _scale -> text (c);
   _scale -> position (tex2 + dx * total, tey2 + dy * total);
   _scale -> boundingBox(ltx1, lty1, ltx2, lty2);

   // determina qual é o maior boundingBox, se o do primeiro ou o do último
   // texto na escala
   double mor = ((ltx2 - ltx1) > (ftx2 - ftx1))
              ? axis -> max()
              : axis -> first();

   // maior texto na escala colocado no primeiro tick
   tm = (int) mor;
   tm += (time_t)_delta;
   lt = localtime(&tm);
   if ( lt->tm_isdst > 0 ) tm -= 60*60;

   lt = localtime(&tm);
   lt->tm_mon += 1;
   lt->tm_year += 1900;
   sprintf (c, FORMAT_STRING, 
         lt->tm_mday, lt->tm_mon, lt->tm_year,
         lt->tm_hour, lt->tm_min, lt->tm_sec );

   _scale -> text (c);
   _scale -> position (tex2, tey2);
   _scale -> boundingBox(ftx1, fty1, ftx2, fty2);

   // próximo tick
   tex2 += dx;
   tey2 += dy;
                
   // maior texto na escala colocado no segundo tick
   _scale -> text (c);
   _scale -> position (tex2, tey2);
   _scale -> boundingBox(ltx1, lty1, ltx2, lty2);

   // guarda quantidade de ticks sem texto
   int test_intercept = 1;
        
   // maior texto na escala colocado nos demais ticks até que não haja
   // interseção do seu boundingBox no tick anterior com o tick atual
   while (mtIntercept (ftx1, fty1, ftx2, fty2, ltx1, lty1, ltx2, lty2) != 0)
   {
      ++test_intercept;

      // próximo tick
      tex2 += dx;
      tey2 += dy;
                
      // maior texto na escala colocado nos demais ticks
      _scale -> text (c);
      _scale -> position (tex2, tey2);
      _scale -> boundingBox(ltx1, lty1, ltx2, lty2);
   }

   // quantidade de ticks no eixo
   int ntick = 0;

   for (double tick = axis -> first();
        mtLessEqual ( tick, axis -> max() );
        tick += axis -> step())
   {
      // formata texto
      tm = (int) tick;
      tm += (time_t)_delta;
   lt = localtime(&tm);
   if ( lt->tm_isdst > 0 ) tm -= 60*60;

      lt = localtime(&tm);
      lt->tm_mon += 1;
      lt->tm_year += 1900;
      sprintf (c, FORMAT_STRING, 
          lt->tm_mday, lt->tm_mon, lt->tm_year,
               lt->tm_hour, lt->tm_min, lt->tm_sec );

            // define o texto
      _scale -> text (c);
      _scale -> position (ex2, ey2);

      if (ntick % test_intercept == 0)
         // desenha a escala
         _scale -> draw (xmn, ymn, xmx, ymx);

      // próximo tick
      ex2 += dx;
      ey2 += dy;

      ++ntick;
   }
}

void XYDateScaleDecorator::boundingBox (const XYAxis *axis, int& bxmin,
                                        int& bymin, int& bxmax,
                                        int& bymax) const
{
   // intervalos de deslocamento em relação as direções x e y
   double dx, dy;
   double rot_rad = axis -> rotation() * XY_PI / 180.0;

   mtRotate ((axis -> step() * axis -> size()) / (axis -> max()
             - axis -> min()), 0, rot_rad, &dx, &dy);

   double ex1, ey1, ex2, ey2;
   axis -> firstTick (ex1, ey1, ex2, ey2);

   // consulta área do gráfico para o eixo
   int xmn, ymn, xmx, ymx;
   axis -> getViewport(xmn, xmx, ymn, ymx);

   // decide área no gráfico para a escala
   _scale -> setViewport(xmn, xmx, ymn, ymx);

   double tex2 = ex2;
   double tey2 = ey2;

   int ftx1, ftx2, fty1, fty2;
   int ltx1, ltx2, lty1, lty2;

   // calcula ticks que receberão labels para não haver sobreposição de labels,
   // o metodo é calcular boundindBox do maior label em ticks consecutivos e
   // verificar quando deixa de ocorrer sobreposição

   // consulta o boundingBox do primeiro texto na escala
   char c[80];
   struct tm *lt; 
   time_t time = (int) axis -> first();
   time += (time_t)_delta;
   lt = localtime(&time);
   if ( lt->tm_isdst > 0 ) time -= 60*60;

   lt = localtime(&time);
   lt->tm_mon += 1;
   lt->tm_year += 1900;

   sprintf (c, FORMAT_STRING, 
            lt->tm_mday, lt->tm_mon, lt->tm_year,
            lt->tm_hour, lt->tm_min, lt->tm_sec );

   _scale -> text (c);
   _scale -> position (tex2, tey2);
   _scale -> boundingBox(ftx1, fty1, ftx2, fty2);

   // quantidade total de ticks
   int total = (int) floor ((axis -> max() - axis -> first())
             / axis -> step());

   // consulta o boundingBox do último texto na escala
   time = (int) axis -> max();
   time += (time_t)_delta;
   lt = localtime(&time);
   if ( lt->tm_isdst > 0 ) time -= 60*60;

   lt = localtime(&time);
   lt->tm_mon += 1;
   lt->tm_year += 1900;

   sprintf (c, FORMAT_STRING, 
         lt->tm_mday, lt->tm_mon, lt->tm_year,
         lt->tm_hour, lt->tm_min, lt->tm_sec );

   _scale -> text (c);
   _scale -> position (tex2 + dx * total, tey2 + dy * total);
   _scale -> boundingBox(ltx1, lty1, ltx2, lty2);

   // determina qual é o maior boundingBox, se o do primeiro ou o do último
   // texto na escala
   double mor = ((ltx2 - ltx1) > (ftx2 - ftx1)) ? axis -> max()
              : axis -> first();

   // maior texto na escala colocado no primeiro tick
   time = (int) mor;
   time += (time_t)_delta;
   lt = localtime(&time);
   if ( lt->tm_isdst > 0 ) time -= 60*60;

   lt = localtime(&time);
   lt->tm_mon += 1;
   lt->tm_year += 1900;

   sprintf (c, FORMAT_STRING, 
         lt->tm_mday, lt->tm_mon, lt->tm_year, 
         lt->tm_hour, lt->tm_min, lt->tm_sec );

   _scale -> text (c);
   _scale -> position (tex2, tey2);
   _scale -> boundingBox(ftx1, fty1, ftx2, fty2);

   // próximo tick
   tex2 += dx;
   tey2 += dy;

   // maior texto na escala colocado no segundo tick

   _scale -> text (c);
   _scale -> position (tex2, tey2);
   _scale -> boundingBox(ltx1, lty1, ltx2, lty2);

   // guarda quantidade de ticks sem texto
   int test_intercept = 1;

   // maior texto na escala colocado nos demais ticks até que não haja
   // interseção do seu boundingBox no tick anterior com o tick atual
   while (mtIntercept (ftx1, fty1, ftx2, fty2, ltx1, lty1, ltx2, lty2) != 0)
   {
      ++test_intercept;

      // próximo tick
      tex2 += dx;
      tey2 += dy;

      // maior texto na escala colocado nos demais ticks

      _scale -> text (c);
      _scale -> position (tex2, tey2);
      _scale -> boundingBox(ltx1, lty1, ltx2, lty2);
   }

   // inicializa boundingBox com posição de referência do primeiro texto
   double xmin = ex2;
   double xmax = ex2;
   double ymin = ey2;
   double ymax = ey2;

   int x1, x2, y1, y2;
   double wx1, wy1, wx2, wy2;

   // quantidade de ticks no eixo
   int ntick = 0;

   for (double tick = axis -> first();
        tick <= axis -> max();
        tick += axis -> step())
   {
      // formata texto
      time_t tm = (int) tick;
      tm += (time_t)_delta;
   lt = localtime(&tm);
   if ( lt->tm_isdst > 0 ) tm -= 60*60;

      lt = localtime(&tm);
      lt->tm_mon += 1;
      lt->tm_year += 1900;

      sprintf (c, FORMAT_STRING, 
          lt->tm_mday, lt->tm_mon, lt->tm_year,
               lt->tm_hour, lt->tm_min, lt->tm_sec );

            // define o texto
      _scale -> text (c);
      _scale -> position (ex2, ey2);

      if ((ntick % test_intercept) == 0)
      {
               // calcula boundingBox do texto
         _scale -> boundingBox (x1, y1, x2, y2);

             wdCanvas2World (x1, y1, &wx1, &wy1);
             wdCanvas2World (x2, y2, &wx2, &wy2);

           // atualiza boundingBox total
           xmin = MIN3 (xmin, wx1, wx2);
           xmax = MAX3 (xmax, wx1, wx2);
           ymin = MIN3 (ymin, wy1, wy2);
           ymax = MAX3 (ymax, wy1, wy2);
      }

      // próximo tick
      ex2 += dx;
      ey2 += dy;

      ++ntick;
   }

   wdWorld2Canvas (xmin, ymin, &bxmin, &bymin);
   wdWorld2Canvas (xmax, ymax, &bxmax, &bymax);
}

---

XY
Tecgraf / PUC-Rio - Computer Graphics Technology Group