//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include <math.h>
#include <Math.hpp>
#include "screenTV.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma link "LetreroDigital"
#pragma resource "*.dfm"
TscreenerTV *screenerTV;
//---------------------------------------------------------------------------
__fastcall TscreenerTV::TscreenerTV(TComponent* Owner)
        : TForm(Owner)
{
   Randomize();
   idx = 0;lf=0;

   pvp = new TProds * [PROD_ROWS*PROD_COLS];


   filas=12;
   etiquetas = new TLabel* [filas*2];
   for (int i=0; i<filas*2; i++)
   {
        etiquetas[i] = new TLabel(this);
        etiqueta = etiquetas[i];

            etiqueta->WordWrap = true;
            etiqueta->AutoSize = false;
            etiqueta->Transparent = false;
            etiqueta->Font->Name="Arial Black";
            etiqueta->Font->Size = 24;
            etiqueta->Font->Color = clSkyBlue;

            etiqueta->Height = 45;

            etiqueta->Top = 10+40*(i/2);

        if (i%2)
        {
            etiqueta->Left = 655;
            etiqueta->Alignment = taRightJustify;
            etiqueta->Caption = ""; // €
            etiqueta->Width = 129;
        } else {
            etiqueta->Left = 10;
            etiqueta->Alignment = taLeftJustify;
            etiqueta->Caption = ""; // descr
            etiqueta->Width = 593;
        }

            this->InsertControl(etiqueta);
   }

}
//---------------------------------------------------------------------------
void __fastcall TscreenerTV::Timer1Timer(TObject *Sender)
{
   // Bucle del programa
   int x,y;
   bool enc = false;

   if ( f==0 )
   {
     etiquetas[lf*2]->Font->Size = 24;
     etiquetas[lf*2+1]->Font->Size = 24;

     etiquetas[lf*2]->Font->Color = clSkyBlue;
     etiquetas[lf*2+1]->Font->Color = clSkyBlue;
   }

   if ( f>0 )
   {
     etiquetas[(f-1)*2]->Font->Size = 24;
     etiquetas[(f-1)*2+1]->Font->Size = 24;

     etiquetas[(f-1)*2]->Font->Color = clSkyBlue;
     etiquetas[(f-1)*2+1]->Font->Color = clSkyBlue;
   }

   if ( f<filas )
   {
     etiquetas[f*2]->Font->Color = clRed;
     etiquetas[f*2+1]->Font->Color = clRed;

     while ( idx<(PROD_ROWS*PROD_COLS) && pvp[idx]->PVPcurr==0 ) idx++;

     if ( idx<(PROD_ROWS*PROD_COLS) )
     {
             etiquetas[f*2]->Caption = pvp[idx]->descr;
             etiquetas[f*2+1]->Caption = CurrToStrF(pvp[idx]->PVPcurr, ffCurrency, 2);
             idx++;
     } else {
             etiquetas[f*2]->Caption = "";
             etiquetas[f*2+1]->Caption = "";
     }

     etiquetas[f*2]->Font->Size = 28;
     etiquetas[f*2+1]->Font->Size = 28;


//            etiqueta->Height = 90;

     etiquetas[f*2]->BringToFront();
     etiquetas[f*2+1]->BringToFront();
   }


   if ( f>=filas || idx>=(PROD_ROWS*PROD_COLS) )
   {
    if ( idx>=(PROD_ROWS*PROD_COLS) ) {lf=f;idx=0;}
    f=0;
   } else
    f++;
/*
   for ( int i=0;i<(filas*2);i++ )
   {
   
     y = 10 + 40 * i;
     for ( j=0;j<2;j++ )
     {

        // Calculamos las coordenadas correctas para cada etiqueta
        if ( j==0 ) x = 10; else x = 655;

        if ( etiquetas[z]->Left < x ) { etiquetas[z]->Left+=1; enc=true; } else
        if ( etiquetas[z]->Left > x ) { etiquetas[z]->Left-=1; enc=true; }

        if ( etiquetas[z]->Top < y ) { etiquetas[z]->Top+=1; enc=true; } else
        if ( etiquetas[z]->Top > y ) { etiquetas[z]->Top-=1; enc=true; }


         etiquetas[z]->Left = x;
         etiquetas[z]->Top = y;
        z++;

     }
   }
*/


   enc = true;
   if (!enc) Timer1->Enabled = false;



}

//---------------------------------------------------------------------------
#ifndef PI
#define PI 3.1415927
#endif

void __fastcall TscreenerTV::desordenAleatorio(void)
{
  f = 0;
/*
    Extended s,c;
    int x, y;
    int length = this->Width/2 + 100;
    float angle = 0.0;
    float angle_stepsize = 0.1;

    int wX, wY;
    wX = this->Width/2;
    wY = this->Height/2;

   // Desordenamos radialmente todas las etiquetas...
   for (int i=0; i<filas*2; i++)
   {
        angle = angle_stepsize * RandomRange(0,60);
        SinCos(angle,s,c);
        x = length * c;
        y = length * s;

        etiquetas[i]->Left = wX + x;
        etiquetas[i]->Top = wY + y;
   }
*/
   Timer1->Enabled=true;
}
//---------------------------------------------------------------------------

/* Esto es un circulo
#ifndef PI
#define PI 3.1415927
#endif


    int x, y;
    int length = 50;
    float angle = 0.0;
    float angle_stepsize = 0.1;

    // go through all angles from 0 to 2 * PI radians
    while (angle < 2 * PI)
    {
        // calculate x, y from a vector with known length and angle
        x = length * cos (angle);
        y = length * sin (angle);

        putpixel (screen,
            x + SCREEN_W / 2, y + SCREEN_H / 2,
            makecol (255, 255, 255));
        angle += angle_stepsize;
    }

*/
void __fastcall TscreenerTV::FormDestroy(TObject *Sender)
{
  delete[] pvp;
}
//---------------------------------------------------------------------------
void __fastcall TscreenerTV::reOrdenar(TProds *p)
{
  f=0;
  idx=0;

  for (int i=0;i<PROD_ROWS*PROD_COLS;i++)
        pvp[i] = &p[i];


  sort(pvp,PROD_ROWS*PROD_COLS);

 Timer1->Enabled=true;



}
//---------------------------------------------------------------------------

