psscale.cpp

用于开发Atmel的AVR系列单片机的GCC集成开发环境

//---------------------------------------------------------------------------
#include <vcl\vcl.h>
#pragma hdrstop

#include "math.h"
#include "PSScale.h"
#pragma link "PSBevel"
#pragma link "PSGradient"
#pragma link "PSScale"
//---------------------------------------------------------------------------
__fastcall TPSScale::TPSScale(void)
{
 FLine = true;
 FFatLine = true;
 FSide = pssBoth;
 FSteps = 6;
 FSub = 4;
 Min = -20;
 Max = 100;
 FStepLen = 10;
 FSubLen = 5;
 FSpace = 10;
 FScaleFont = new TFont;
 FColor_1 = clLime, FColor_2 = clYellow, FColor_3 = clRed;
 FColor_4 = clGreen, FColor_5 = clBlue;
 FScaleColor = clBlack;
 FStart_1 = 0, FStop_1 = 0, FStart_2 = 0, FStop_2 = 0;
 FStart_3 = 0, FStop_3 = 0, FStart_4 = 0, FStop_4 = 0;
 FStart_5 = 0, FStop_5 = 0;
}
//---------------------------------------------------------------------------
__fastcall TPSScale::~TPSScale(void)
{
 delete FScaleFont;
}
//---------------------------------------------------------------------------
void __fastcall TPSScale::SetLine (bool val)
{
 FLine = val;
 Change ();
}
//---------------------------------------------------------------------------
void __fastcall TPSScale::SetFatLine (bool val)
{
 FFatLine = val;
 Change ();
}
//---------------------------------------------------------------------------
void __fastcall TPSScale::SetSide (TPSScaleSide val)
{
 FSide = val;
 Change ();
}
//---------------------------------------------------------------------------
void __fastcall TPSScale::SetSteps (int val)
{
 FSteps = val;
 Change ();
}
//---------------------------------------------------------------------------
void __fastcall TPSScale::SetSub (int val)
{
 FSub = val;
 Change ();
}
//---------------------------------------------------------------------------
void __fastcall TPSScale::SetStepLen (int val)
{
 FStepLen = val;
 Change ();
}
//---------------------------------------------------------------------------
void __fastcall TPSScale::SetSubLen (int val)
{
 FSubLen = val;
 Change ();
}
//---------------------------------------------------------------------------
void __fastcall TPSScale::SetSpace (int val)
{
 FSpace = val;
 Change ();
}
//---------------------------------------------------------------------------
void __fastcall TPSScale::SetColor_1 (TColor val)
{
 FColor_1 = val;
 Change ();
}
//---------------------------------------------------------------------------
void __fastcall TPSScale::SetColor_2 (TColor val)
{
 FColor_2 = val;
 Change ();
}
//---------------------------------------------------------------------------
void __fastcall TPSScale::SetColor_3 (TColor val)
{
 FColor_3 = val;
 Change ();
}
//---------------------------------------------------------------------------
void __fastcall TPSScale::SetColor_4 (TColor val)
{
 FColor_4 = val;
 Change ();
}
//---------------------------------------------------------------------------
void __fastcall TPSScale::SetColor_5 (TColor val)
{
 FColor_5 = val;
 Change ();
}
//---------------------------------------------------------------------------
void __fastcall TPSScale::SetStart_1 (double val)
{
 FStart_1 = val;
 Change ();
}
//---------------------------------------------------------------------------
void __fastcall TPSScale::SetStop_1 (double val)
{
 FStop_1 = val;
 Change ();
}
//---------------------------------------------------------------------------
void __fastcall TPSScale::SetStart_2 (double val)
{
 FStart_2 = val;
 Change ();
}
//---------------------------------------------------------------------------
void __fastcall TPSScale::SetStop_2 (double val)
{
 FStop_2 = val;
 Change ();
}
//---------------------------------------------------------------------------
void __fastcall TPSScale::SetStart_3 (double val)
{
 FStart_3 = val;
 Change ();
}
//---------------------------------------------------------------------------
void __fastcall TPSScale::SetStop_3 (double val)
{
 FStop_3 = val;
 Change ();
}
//---------------------------------------------------------------------------
void __fastcall TPSScale::SetStart_4 (double val)
{
 FStart_4 = val;
 Change ();
}
//---------------------------------------------------------------------------
void __fastcall TPSScale::SetStop_4 (double val)
{
 FStop_4 = val;
 Change ();
}
//---------------------------------------------------------------------------
void __fastcall TPSScale::SetStart_5 (double val)
{
 FStart_5 = val;
 Change ();
}
//---------------------------------------------------------------------------
void __fastcall TPSScale::SetStop_5 (double val)
{
 FStop_5 = val;
 Change ();
}
//---------------------------------------------------------------------------
void __fastcall TPSScale::Change (void)
{
 if (OnChange) OnChange (this);
}
//---------------------------------------------------------------------------
void __fastcall TPSScale::DrawHScale (Graphics::TCanvas *can, TRect rect)
{
 int upper, lower, i, s, texth, textw;
 double temp, stemp, fstep, fsub, valpos, valinc, starray[5], sparray[5];
 AnsiString Text;
 TColor carray[5];
 
 if (FSide == pssNone) return;
 upper = (rect.Bottom - rect.Top - FSpace) / 2;
 lower = upper + FSpace;

 can->Font = FScaleFont;

 ValToArray (starray, sparray, carray);
 can->Pen->Width = 5;
 for (i = 0;i < 5;i++)
 {
  if (sparray[i] <= starray[i] || starray[i] < Min || sparray[i] > Max) break;
  stemp = rect.Left + ((double)(rect.Right - rect.Left) / (double)(Max - Min) *
                         (double)(starray[i] - Min));
  temp = rect.Left + ((double)(rect.Right - rect.Left) / (double)(Max - Min) *
                        (double)(sparray[i] - Min));
  stemp += 2;
  temp -= 2;
  can->Pen->Color = carray[i];
  if (FSide == pssUpper || FSide == pssBoth)
  {
   can->MoveTo (stemp, upper - 3);
   can->LineTo (temp, upper - 3);
  }
  if (FSide == pssLower || FSide == pssBoth)
  {
   can->MoveTo (stemp, lower + 3);
   can->LineTo (temp, lower + 3);
  }
 }
 can->Pen->Color = FScaleColor;
 // Draw Lines
 if (FLine)
 {
  if (FFatLine) can->Pen->Width = 2;
  else can->Pen->Width = 1;
  if (FSide == pssUpper || FSide == pssBoth)
  {
   can->MoveTo (rect.Left, upper);
   can->LineTo (rect.Right, upper);
  }
  if (FSide == pssLower || FSide == pssBoth)
  {
   can->MoveTo (rect.Left, lower);
   can->LineTo (rect.Right, lower);
  }
 }

 temp = (double)(rect.Right - rect.Left) / FSteps;
 stemp = temp / FSub;
 valinc = (double)(Max - Min) / FSteps;
 valpos = Min;
 if (stemp < 1 || temp < 1) return;
 SetBkMode (can->Handle, TRANSPARENT);
 for (i = 0, fstep = 0;i <= FSteps;i++, fstep += temp)
 {
  Text = AnsiString (int((int)valpos));
  textw = can->TextWidth (Text);
  texth = can->TextHeight (Text);
  if (FFatLine) can->Pen->Width = 2;
  else can->Pen->Width = 1;
  if (FSide == pssUpper || FSide == pssBoth)
  {
   can->MoveTo (rect.Left + fstep, upper);
   can->LineTo (rect.Left + fstep, upper - 10);
   can->TextOut (rect.Left + fstep - (textw / 2), upper - 11 - texth , Text);
  }
  if (FSide == pssLower || FSide == pssBoth)
  {
   can->MoveTo (rect.Left + fstep, lower);
   can->LineTo (rect.Left + fstep, lower + 10);
   can->TextOut (rect.Left + fstep - (textw / 2), lower + 12, Text);
  }

  if (i == FSteps) break;
  valpos += valinc;
  for (s = 1, fsub = stemp;s < FSub;s++, fsub += stemp)
  {
   can->Pen->Width = 1;
   if (FSide == pssUpper || FSide == pssBoth)
   {
    can->MoveTo (rect.Left + fstep + fsub, upper);
    can->LineTo (rect.Left + fstep + fsub, upper - 5);
   }
   if (FSide == pssLower || FSide == pssBoth)
   {
    can->MoveTo (rect.Left + fstep + fsub, lower);
    can->LineTo (rect.Left + fstep + fsub, lower + 5);
   }
  }
 }

}
//---------------------------------------------------------------------------
void __fastcall TPSScale::DrawVScale (Graphics::TCanvas *can, TRect rect)
{
 int upper, lower, i, s, texth, textw;
 double temp, stemp, fstep, fsub, valpos, valinc, starray[5], sparray[5];
 bool nearbottom;
 AnsiString Text;
 TColor carray[5];

 can->Font = FScaleFont;

 if (FSide == pssNone) return;
 upper = (rect.Right - rect.Left - FSpace) / 2;
 lower = upper + FSpace;

 ValToArray (starray, sparray, carray);
 can->Pen->Width = 5;
 for (i = 0;i < 5;i++)
 {
  if (sparray[i] > starray[i] && starray[i] >= Min && sparray[i] <= Max)
  {
   stemp = rect.Bottom - ((double)(rect.Bottom - rect.Top) / (double)(Max - Min) *
                          (double)(starray[i] - Min));
   temp = rect.Bottom - ((double)(rect.Bottom - rect.Top) / (double)(Max - Min) *
                         (double)(sparray[i] - Min));
   stemp -= 2;
   temp += 2;
   if ((rect.Bottom - temp) < (temp - rect.Top)) nearbottom = true;
   else nearbottom = false;
   if (stemp < temp && !nearbottom) stemp = temp;
   if (stemp < temp && nearbottom) temp = stemp;
   can->Pen->Color = carray[i];
   if (FSide == pssUpper || FSide == pssBoth)
   {
    can->MoveTo (upper - 3, stemp);
    can->LineTo (upper - 3, temp);
   }
   if (FSide == pssLower || FSide == pssBoth)
   {
    can->MoveTo (lower + 3, stemp);
    can->LineTo (lower + 3, temp);
   }
  }
 }
 can->Pen->Color = FScaleColor;
 // Draw Lines
 if (FLine)
 {
  if (FFatLine) can->Pen->Width = 2;
  else can->Pen->Width = 1;
  if (FSide == pssUpper || FSide == pssBoth)
  {
   can->MoveTo (upper, rect.Bottom);
   can->LineTo (upper, rect.Top);
  }
  if (FSide == pssLower || FSide == pssBoth)
  {
   can->MoveTo (lower, rect.Bottom);
   can->LineTo (lower, rect.Top);
  }
 }

 temp = (double)(rect.Bottom - rect.Top) / FSteps;
 stemp = temp / FSub;
 valinc = (double)(Max - Min) / FSteps;
 valpos = Min;
 if (stemp < 1 || temp < 1) return;
 SetBkMode (can->Handle, TRANSPARENT);
 for (i = 0, fstep = 0;i <= FSteps;i++, fstep += temp)
 {
  Text = AnsiString (int((int)valpos));
  textw = can->TextWidth (Text);
  texth = can->TextHeight (Text);
  if (FFatLine) can->Pen->Width = 2;
  else can->Pen->Width = 1;
  if (FSide == pssUpper || FSide == pssBoth)
  {
   can->MoveTo (upper, rect.Bottom - fstep);
   can->LineTo (upper - FStepLen, rect.Bottom - fstep);
   can->TextOut (upper - FStepLen - 3 - textw, rect.Bottom -
                 fstep - (texth / 2) , Text);
  }
  if (FSide == pssLower || FSide == pssBoth)
  {
   can->MoveTo (lower, rect.Bottom - fstep);
   can->LineTo (lower + FStepLen, rect.Bottom - fstep);
   can->TextOut (lower + FStepLen + 2, rect.Bottom - fstep - (texth / 2), Text);
  }

  if (i == FSteps) break;
  valpos += valinc;
  for (s = 1, fsub = stemp;s < FSub;s++, fsub += stemp)
  {
   can->Pen->Width = 1;
   if (FSide == pssUpper || FSide == pssBoth)
   {
    can->MoveTo (upper, rect.Bottom - fstep - fsub);
    can->LineTo (upper - FSubLen, rect.Bottom - fstep - fsub);
   }
   if (FSide == pssLower || FSide == pssBoth)
   {
    can->MoveTo (lower, rect.Bottom - fstep - fsub);
    can->LineTo (lower + FSubLen, rect.Bottom - fstep - fsub);
   }
  }
 }

}
//---------------------------------------------------------------------------
void __fastcall TPSScale::ValToArray (double *starray, double *sparray, TColor *carray)
{
 *starray = FStart_1;
 *(starray + 1) = FStart_2;
 *(starray + 2) = FStart_3;
 *(starray + 3) = FStart_4;
 *(starray + 4) = FStart_5;
 *sparray = FStop_1;
 *(sparray + 1) = FStop_2;
 *(sparray + 2) = FStop_3;
 *(sparray + 3) = FStop_4;
 *(sparray + 4) = FStop_5;
 *carray = FColor_1;
 *(carray + 1) = FColor_2;
 *(carray + 2) = FColor_3;
 *(carray + 3) = FColor_4;
 *(carray + 4) = FColor_5;
}
//---------------------------------------------------------------------------
void __fastcall TPSScale::DrawAScale (Graphics::TCanvas *can, TRect rect, int start, int angle)
{
 int r, i, s, texth, textw;
 double x, y, xm, ym, alpha, atemp, stangle, spangle, starray[5], sparray[5];
 double pi = 3.1415926535898;
 AnsiString Text;
 TColor carray[5];

 can->Font = FScaleFont;

 if ((rect.Right - rect.Left) < (rect.Bottom - rect.Top))
     r = (rect.Right - rect.Left) / 2;
 else r = (rect.Bottom - rect.Top) / 2;

 ValToArray (starray, sparray, carray);
 can->Pen->Width = 5;
 for (i = 0;i < 5;i++)
 {
  if (sparray[i] <= starray[i] || starray[i] < Min || sparray[i] > Max) break;
  stangle = ((double)(angle - start) / (double)(Max - Min) *
             (double)(starray[i] - Min)) + start;
  spangle = ((double)(angle - start) / (double)(Max - Min) *
             (double)(sparray[i] - Min)) + start;
  stangle += 1;
  spangle -= 1;
  alpha = pi + (pi / 180 * spangle);
  xm = ((double)r * cos(alpha)) + r + rect.Left;
  ym = ((double)r * sin(alpha)) + r + rect.Top;
  alpha = pi + (pi / 180 * stangle);
  x = ((double)r * cos(alpha)) + r + rect.Left;
  y = ((double)r * sin(alpha)) + r + rect.Top;
  can->Pen->Color = carray[i];
  can->Arc (rect.Left - 3, rect.Top - 3, (2 * r) + rect.Left + 3,
           (2 * r) + rect.Top + 3, xm, ym, x, y);
 }

 can->Pen->Color = FScaleColor;
 alpha = pi + (pi / 180 * angle);
 xm = ((double)r * cos(alpha)) + r + rect.Left;
 ym = ((double)r * sin(alpha)) + r + rect.Top;
 alpha = pi + (pi / 180 * start);
 x = ((double)r * cos(alpha)) + r + rect.Left;
 y = ((double)r * sin(alpha)) + r + rect.Top;

 if (FFatLine) can->Pen->Width = 2;
 else can->Pen->Width = 1;
 can->Arc (rect.Left, rect.Top, (2 * r) + rect.Left,
           (2 * r) + rect.Top, xm, ym, x, y);

 atemp = ((double)angle - (double)start) / (double)FSteps;
 for (i = 0; i <= FSteps;i++)
 {
  if (FFatLine) can->Pen->Width = 2;
  alpha = pi + (pi / 180 * ((atemp * i) + start));
  xm = cos(alpha);
  ym = sin(alpha);
  x = r + rect.Left + (xm * (double)r);
  y = r + rect.Top + (ym * (double)r);
  can->MoveTo (x, y);
  x = r + rect.Left + (xm * ((double)r + (double)FStepLen));
  y = r + rect.Top + (ym * ((double)r + (double)FStepLen));
  can->LineTo (x, y);
  Text = AnsiString (int(((Max - Min) / FSteps * i) + Min));
  texth = can->TextHeight (Text);
  textw = can->TextWidth (Text);

  x = r + rect.Left + (xm * ((double)r + FStepLen + 2 + (textw / 2)));
  y = r + rect.Top + (ym * ((double)r + FStepLen + 2 + (texth / 2)));
  can->TextOut (x - (textw / 2), y - (texth / 2), Text);

  if (i == FSteps) break;
  for (s = 1;s < FSub;s++)
  {
   can->Pen->Width = 1;
   alpha = pi + (pi / 180 * (((double)i * atemp) + (atemp /
                 (double)FSub * (double)s) + (double)start));
   xm = cos(alpha);
   ym = sin(alpha);
   x = (double)r + (double)rect.Left + (xm * (double)r);
   y = (double)r + (double)rect.Top + (ym * (double)r);
   can->MoveTo (x, y);
   x = (double)r + (double)rect.Left + (xm * ((double)r + (double)FSubLen));
   y = (double)r + (double)rect.Top + (ym * ((double)r + (double)FSubLen));
   can->LineTo (x, y);
  }
 }
}