GUIWx.cpp

Go to the documentation of this file.

#include "GUIWx.h"
#include "Vector2.h"
#include <wx/textctrl.h>
#include <wx/dcmemory.h>
#include <wx/statusbr.h>
#include <wx/pen.h>

GUIWx::GUIWx(int iniPanX, int iniPanY, float zoom, wxStatusBar *iniStatusBar) :
    GUI(iniPanX, iniPanY, zoom),//int iniPanX, int iniPanY, float zoom, int signX = 1, int signY = -1
    dc(0),
    statusBar(iniStatusBar){  
}

GUIWx::~GUIWx(){
}

void GUIWx::setDC(wxDC *iniDC) {
    dc = iniDC;
}

void GUIWx::clear(){
   dc->Clear();
}

void GUIWx::drawCircle(float x, float y, float r) {
    dc->DrawCircle(mapX(x), mapY(y), mapLen(r));
}

void GUIWx::drawLine(float x1, float y1, float x2, float y2) {
    dc->DrawLine(mapX(x1), mapY(y1), mapX(x2), mapY(y2));
}

void GUIWx::drawRectangle(float x, float y, float w, float h) {
    dc->DrawRectangle(mapX(x), mapY(y), (int)(zoomX * w), (int)(zoomY * h));
}

inline static float cosSum(float cos1, float sin1, float cos2, float sin2) {
    return cos1 * cos2 - sin1 * sin2;
}

inline static float sinSum(float cos1, float sin1, float cos2, float sin2) {
    return cos1 * sin2 + sin1 * cos2;
}

void GUIWx::drawCappedRectangle(float x, float y, float l, float R, float alpha) {
    static const float cos_pi5  = cos(M_PI/5);
    static const float sin_pi5  = sin(M_PI/5);
    static const float cos_2pi5 = cos(2 * M_PI / 5);
    static const float sin_2pi5 = sin(2 * M_PI / 5);
    float cosAlpha = cos(alpha);
    float sinAlpha = sin(alpha);
    float lcos = l * cosAlpha;
    float lsin = l * sinAlpha;
    float Rcos = R * cosAlpha;
    float Rsin = R * sinAlpha;

    float xc[6];
    float yc[6];

    xc[0] = Rsin;
    yc[0] = -Rcos;
    
    xc[1] = cosSum(Rsin, -Rcos, cos_pi5, sin_pi5);
    yc[1] = sinSum(Rsin, -Rcos, cos_pi5, sin_pi5);

    xc[2] = cosSum(Rsin, -Rcos, cos_2pi5, sin_2pi5);
    yc[2] = sinSum(Rsin, -Rcos, cos_2pi5, sin_2pi5);
    
    xc[3] = cosSum(Rsin, -Rcos, -cos_2pi5, sin_2pi5);
    yc[3] = sinSum(Rsin, -Rcos, -cos_2pi5, sin_2pi5);

    xc[4] = cosSum(Rsin, -Rcos, -cos_pi5, sin_pi5);
    yc[4] = sinSum(Rsin, -Rcos, -cos_pi5, sin_pi5);

    xc[5] = -Rsin;
    yc[5] = Rcos;

    wxPoint points[12];
    for (int i = 0; i < 6; ++i) {
        points[i].x     = mapX(x + lcos + xc[i]);
        points[i].y     = mapY(y + lsin + yc[i]);
        points[i + 6].x = mapX(x - lcos - xc[i]);
        points[i + 6].y = mapY(y - lsin - yc[i]);
    }

    dc->DrawPolygon(12, points, 0, 0);
}

void GUIWx::setBrushColor(Color color) {
   if(color.transparent){
      dc->SetBrush(*wxTRANSPARENT_BRUSH);
   } else {
      dc->SetBrush(*(wxTheBrushList->FindOrCreateBrush(wxColour(color.r, color.g, color.b),wxSOLID)));
   }
}

void GUIWx::setPenColor(Color color) {
   if(color.transparent){
      dc->SetPen(*wxTRANSPARENT_PEN);
   } else {
      dc->SetPen(*(wxThePenList->FindOrCreatePen(wxColour(color.r, color.g, color.b),1,wxSOLID)));
   }
}

void GUIWx::outText(const char* s){
   outTextStatusBar(s);
}

void GUIWx::outTextStatusBar(const char* s, int pos){
    if (statusBar) {
        statusBar->SetStatusText(s, pos);
    }
}

void GUIWx::drawArrow(float x1, float y1, float x2, float y2) {
    static const float arrowAngle = (float) M_PI / 8;
    static const float sinArrow   = sinf(arrowAngle);
    static const float cosArrow   = cosf(arrowAngle);
   //the length of the arrow tip:
   static const float arrowLength= (float) 0.08; 
   //the minimum length of the vector at which the arrow tip is drawn with 
   //default length; otherwise the arrow tip is drawn at vector length /2
   static const float minLength= 2*arrowLength; 

    drawLine(x1, y1, x2, y2);

    float dx = x1 - x2;
    float dy = y1 - y2;
   float length=sqrt(dx*dx+dy*dy);
    float tipDx, tipDy;
   if (length < minLength) {
      tipDx = dx / 2;
      tipDy = dy / 2;
   } else {
      float tipScale = arrowLength / length;
      tipDx = dx * tipScale;
      tipDy = dy * tipScale;
   }
   
    float dxCos = tipDx * cosArrow;
    float dxSin = tipDx * sinArrow;
    float dyCos = tipDy * cosArrow;
    float dySin = tipDy * sinArrow;
    
    drawLine(x2, y2, x2 + dxCos - dySin, y2 + dxSin + dyCos);
    drawLine(x2, y2, x2 + dxCos + dySin, y2 - dxSin + dyCos);
}

void GUIWx::drawForce(const Vector2& r, const Vector2& force){
   static const real maxForce = (const real) 0.2;
   static const real lengthPerForce=(const real) 0.3 / maxForce;
   drawArrow(r.x, r.y,
              r.x + force.x * lengthPerForce,
              r.y + force.y * lengthPerForce);
}

void GUIWx::drawTorque(const Vector2& r, const real alpha, const real torque){
   static const real maxTorque = (const real)1.2;
   static const real maxRotation=4*M_PI;
   static const real maxRadius=0.1f;
   static const real deltaRadius=0.05f;
   static const int steps=50;
   static const real arrowLength=M_PI/10;
   static const real arrowWidth= .04;
   int i;
   int sign;
   real angle, radius;
   wxCoord x1,x2,y1,y2;

   if(fabs(torque)*steps/maxTorque>1){
        drawLine(r.x, r.y, 
                 r.x + maxRadius * cos(alpha), 
                 r.y + maxRadius * sin(alpha)); 
      if (torque<0) sign=-1; else sign=1;

      x1 = mapX(r.x + maxRadius * cos(alpha));
      y1 = mapY(r.y + maxRadius * sin(alpha));
      
      i=1;
      while(i<steps && i<fabs(torque)*steps/maxTorque){
         angle=alpha+sign*i*maxRotation/steps;
         radius=maxRadius-i*deltaRadius/steps;
         x2=mapX(r.x+radius*cos(angle));
         y2=mapY(r.y+radius*sin(angle));
         dc->DrawLine(x1, y1, x2, y2);
         x1 = x2; 
            y1 = y2;
         i++;
      }
      //draw the arrow of the torque
      x2=x1; y2=y1;
      x1 = mapX(r.x+(radius-arrowWidth)*cos(angle-sign*arrowLength));
      y1 = mapY(r.y+(radius-arrowWidth)*sin(angle-sign*arrowLength));
      dc->DrawLine(x1, y1, x2, y2);
      x1=x2; y1=y2;
      x2 = mapX(r.x+(radius+arrowWidth)*cos(angle-sign*arrowLength));
      y2 = mapY(r.y+(radius+arrowWidth)*sin(angle-sign*arrowLength));
      dc->DrawLine(x1, y1, x2, y2);
   }
}

Thyrix homepage • Users' guide

(C) Arxia 2004-2005