void wxGraphicsContext::SetPen( const wxPen& pen )
{
if ( !pen.Ok() || pen.GetStyle() == wxTRANSPARENT )
SetPen( wxNullGraphicsPen );
else
SetPen( CreatePen( pen ) );
}
wxPen &GetGreyPen(wxPen &pen)
{
static wxPen p;
wxColour c;
p = pen;
c = MakeColourGrey(pen.GetColour());
p.SetColour(c);
return p;
}
/*****************************************************
**
** PdfPainter --- setPen
**
******************************************************/
void PdfPainter:: setPen( const wxPen &p )
{
//const double defaultWidth = 1;
double width = p.GetWidth() * PDF_PEN_PENWIDTH_FACTOR;
wxPdfLineStyle style;
switch ( p.GetStyle() )
{
case wxDOT:
{
wxPdfArrayDouble dash1;
dash1.Add( .5 );
style = wxPdfLineStyle( width, wxPDF_LINECAP_NONE, wxPDF_LINEJOIN_MITER, dash1, 10.);
}
break;
case wxLONG_DASH:
{
wxPdfArrayDouble dash2;
dash2.Add( 3 );
style = wxPdfLineStyle( width, wxPDF_LINECAP_BUTT, wxPDF_LINEJOIN_MITER, dash2, 0.);
break;
}
break;
case wxSHORT_DASH:
{
wxPdfArrayDouble dash3;
dash3.Add( 1.5 );
style = wxPdfLineStyle( width, wxPDF_LINECAP_BUTT, wxPDF_LINEJOIN_MITER, dash3, 0.);
}
case wxDOT_DASH:
{
wxPdfArrayDouble dash4;
dash4.Add( 1.5 );
dash4.Add( 3 );
style = wxPdfLineStyle( width, wxPDF_LINECAP_BUTT, wxPDF_LINEJOIN_MITER, dash4, 0.);
}
break;
default:
// Noting to do
break;
}
style.SetWidth( width );
if ( p.GetColour().IsOk() )
{
style.SetColour( p.GetColour() );
pdf->SetDrawColour( p.GetColour());
}
pdf->SetLineStyle( style );
}
bool wxGenericPen::IsSameAs(const wxPen &pen) const
{
wxCHECK_MSG(Ok() && pen.Ok(), false, wxT("Invalid generic pen"));
wxGenericPen gp(pen);
gp.GetGenericColour().SetAlpha(M_GPENDATA->m_colour.GetAlpha());
return IsSameAs(gp);
}
wxPen GetStyle() const
{
if (!style.IsOk())
/// @todo Make this colour configurable
style = wxPen(wxColour(255,0,255), 1);
return style;
}
void wxQtDCImpl::SetPen(const wxPen& pen)
{
m_pen = pen;
m_qtPainter->setPen(pen.GetHandle());
ApplyRasterColourOp();
}
/*****************************************************
**
** DcPainter --- setPen
**
******************************************************/
void DcPainter::setPen( const wxPen &p )
{
//printf( "DcPainter::setPen OK %d color OK %d\n", p.IsOk(), p.GetColour().IsOk());
if ( ! p.IsOk() )
{
wxLogError( wxT( "pen not okay, using default pen" ));
setDefaultPen();
}
else dc->SetPen( p );
}
void SjOscRocket::Show(wxDC& dc, long light)
{
if(m_sleep)
{
return;
}
if( m_t<m_length )
{
int i, j, x, y, maxL;
double s;
#define VIEW 20
maxL = VIEW;
if( maxL > m_length-m_t )
{
maxL = m_length-m_t;
long intensity = (255/VIEW)*(m_length-m_t);
if( light > intensity ) intensity = light;
m_pen.SetColour(intensity, intensity, intensity);
}
dc.SetPen(m_pen);
wxPoint points[VIEW];
for(i=0; i<m_patch; i++)
{
for( j = 0; j < maxL; j++ )
{
s=(double)(m_t+j)/100;
x=(int)(m_vx[i]*s);
y=(int)(m_vy[i]*s-ROCKET_GRAVITY*s*s);
points[j].x = m_ox+x;
points[j].y = m_oy-y;
}
dc.DrawLines(maxL, points);
}
m_t++;
}
else
{
m_sleep = TRUE;
}
}
void wxGenericPen::Set( const wxPen &pen )
{
wxCHECK_RET(Ok() && pen.Ok(), wxT("Invalid generic pen"));
SetColour(pen.GetColour());
M_GPENDATA->m_width = pen.GetWidth();
M_GPENDATA->m_style = pen.GetStyle();
M_GPENDATA->m_cap = pen.GetCap();
M_GPENDATA->m_join = pen.GetJoin();
wxDash* dash;
int n_dashes = pen.GetDashes(&dash);
SetDashes(n_dashes, dash);
// or SetDashes(pen.GetDashCount(), pen.GetDash()); not in msw 2.4
}
void SjOscRocket::Init(int energy, int patch, int length, long seed, int mx, int my)
{
int i;
m_mx = mx;
m_my = my;
m_energy = energy;
m_patch = patch;
m_length = length;
m_random = seed;
m_pen.SetColour(255, 255, 255);
m_ox=(int)SjTools::Rand(m_mx/2)+m_mx/4;
m_oy=(int)SjTools::Rand(m_my/2)+m_my/4;
for(i=0; i<m_patch; i++)
{
m_vx[i]=(int)SjTools::Rand(m_energy)-m_energy/2;
m_vy[i]=(int)SjTools::Rand(m_energy*7/8)-m_energy/8;
}
}
// Draws a line between (x1,y1) - (x2,y2) with a start thickness of t1
void DrawThickLine( double x1, double y1, double x2, double y2, wxPen pen, bool b_hiqual )
{
double angle = atan2( y2 - y1, x2 - x1 );
double t1 = pen.GetWidth();
double t2sina1 = t1 / 2 * sin( angle );
double t2cosa1 = t1 / 2 * cos( angle );
glPushAttrib( GL_COLOR_BUFFER_BIT | GL_HINT_BIT | GL_POLYGON_BIT ); //Save state
ocpnDC::SetGLAttrs( b_hiqual );
// n.b. The dwxDash interpretation for GL only allows for 2 elements in the dash table.
// The first is assumed drawn, second is assumed space
wxDash *dashes;
int n_dashes = pen.GetDashes( &dashes );
if( n_dashes ) {
double lpix = sqrt( ( x1 - x2 ) * ( x1 - x2 ) + ( y1 - y2 ) * ( y1 - y2 ) );
double lrun = 0.;
double xa = x1;
double ya = y1;
double ldraw = t1 * dashes[0];
double lspace = t1 * dashes[1];
while( lrun < lpix ) {
// Dash
double xb = xa + ldraw * cos( angle );
double yb = ya + ldraw * sin( angle );
if( ( lrun + ldraw ) >= lpix ) // last segment is partial draw
{
xb = x2;
yb = y2;
}
glBegin( GL_TRIANGLES );
glVertex2f( xa + t2sina1, ya - t2cosa1 );
glVertex2f( xb + t2sina1, yb - t2cosa1 );
glVertex2f( xb - t2sina1, yb + t2cosa1 );
glVertex2f( xb - t2sina1, yb + t2cosa1 );
glVertex2f( xa - t2sina1, ya + t2cosa1 );
glVertex2f( xa + t2sina1, ya - t2cosa1 );
glEnd();
xa = xb;
ya = yb;
lrun += ldraw;
// Space
xb = xa + lspace * cos( angle );
yb = ya + lspace * sin( angle );
xa = xb;
ya = yb;
lrun += lspace;
}
} else {
glBegin( GL_TRIANGLES );
glVertex2f( x1 + t2sina1, y1 - t2cosa1 );
glVertex2f( x2 + t2sina1, y2 - t2cosa1 );
glVertex2f( x2 - t2sina1, y2 + t2cosa1 );
glVertex2f( x2 - t2sina1, y2 + t2cosa1 );
glVertex2f( x1 - t2sina1, y1 + t2cosa1 );
glVertex2f( x1 + t2sina1, y1 - t2cosa1 );
glEnd();
}
glPopAttrib();
}
void ThemeBase::SetPenColour( wxPen & Pen, int iIndex )
{
wxASSERT( iIndex >= 0 );
Pen.SetColour( Colour( iIndex ));
}
bool SjOscStar::Draw(wxDC& dc, const wxSize& clientSize, double rot, wxPen& pen, wxBrush& brush)
{
double xfloat, yfloat;
int x, y, hh, vv;
int d, intensity;
m_z -= 2;
if( m_z < -63 )
{
m_z = STAR_DEPTH;
m_doDraw = !m_exitRequest;
}
hh = (m_x*64)/(64+m_z);
vv = (m_y*64)/(64+m_z);
// check position
x = hh + 500;
y = vv + 500;
if( x < -300 || x > 1300 || y < -300 || y > 1300 )
{
m_z = STAR_DEPTH;
m_doDraw = !m_exitRequest;
hh = (m_x*64)/(64+m_z);
vv = (m_y*64)/(64+m_z);
}
// calculate position
xfloat = (hh*cos(rot))-(vv*sin(rot));
yfloat = (hh*sin(rot))+(vv*cos(rot));
x = (int)xfloat + 500;
y = (int)yfloat + 500;
// use star?
if( !m_doDraw )
{
if( m_exitRequest || x < 450 || x > 550 || y < 450 || y > 550 )
{
return FALSE;
}
else
{
m_doDraw = TRUE;
}
}
// map star position to client size, keep aspect ratio
d = clientSize.x;
if( clientSize.y > d )
{
d = clientSize.y;
}
if( d == 0 )
{
d = 10;
}
x = (x * d) / 1000 - (d-clientSize.x)/2;
y = (y * d) / 1000 - (d-clientSize.y)/2;
// calculate size
d = (STAR_DEPTH-m_z) / (38400/d);
if( d == 0 ) d = 1;
// calculate light intensity
intensity = STAR_DEPTH-m_z;
intensity = 55 + ((intensity * 200) / STAR_DEPTH);
//if( intensity < light ) intensity = light + 10;
if( intensity < 0 ) intensity = 0;
if( intensity > 255 ) intensity = 255;
// draw star
if( d==1 )
{
pen.SetColour(intensity, intensity, intensity);
dc.SetPen(pen);
dc.DrawPoint(x, y);
}
else
{
dc.SetPen(*wxTRANSPARENT_PEN);
brush.SetColour(intensity, intensity, intensity);
dc.SetBrush(brush);
dc.DrawRectangle(x, y, d, d);
}
return TRUE;
}
virtual void SetPen(const wxPen& pen) override {
wxPen newpen = pen;
newpen.SetColour(PivotColour(pen.GetColour()));
wxMirrorDC::SetPen(newpen);
}
void SjOscHands::Draw(wxDC& dc, const wxSize& clientSize,
long volume, long light, bool newTitle)
{
long i, offset;
// (re-)calculate log. hand data
if( m_logHandMode == HAND_MODE_NOP )
{
m_pause--;
if( m_pause <= 0 // about once in 90 seconds or every 4 titles
|| (newTitle && !m_firstTitle && SjTools::Rand(4) == 0) )
{
for( i = 0; i < MAX_HANDS; i++ )
{
m_logHandsPos[i].x = i*(1024/MAX_HANDS)+SjTools::Rand((1024/MAX_HANDS)-HAND_W/2);
m_logHandsPos[i].y = ((768-HAND_H) + 10) - SjTools::Rand(20);
m_logHandRnd[i] = 5-SjTools::Rand(10);
if( m_logHandRnd[i] == 0 ) m_logHandRnd[i] = 1;
}
m_logHandMode = HAND_MODE_FADEIN;
m_logHandModeData = HAND_H+volume;
m_pause = (10000+SjTools::Rand(90000))/SLEEP_MS;
offset = m_logHandModeData;
m_firstTitle = FALSE;
}
else
{
if( newTitle ) m_firstTitle = FALSE;
return;
}
}
else if( m_logHandMode == HAND_MODE_FADEIN )
{
m_logHandModeData--;
offset = m_logHandModeData;
if( m_logHandModeData == 0 )
{
m_logHandMode = HAND_MODE_DO;
m_logHandModeData = (10000 + SjTools::Rand(50000)) / SLEEP_MS; // 10-60 seconds
}
}
else if( m_logHandMode == HAND_MODE_DO )
{
m_logHandModeData--;
offset = 0;
if( m_logHandModeData == 0
|| (newTitle && SjTools::Rand(4)==0) )
{
m_logHandMode = HAND_MODE_FADEOUT;
m_logHandModeData = (HAND_H+80);
}
}
else if( m_logHandMode == HAND_MODE_FADEOUT )
{
m_logHandModeData--;
offset = (HAND_H+80) - m_logHandModeData;
if( m_logHandModeData == 0 )
{
m_logHandMode = HAND_MODE_NOP;
return;
}
}
// calculate a hand for the given screen resolution
wxPoint scrHandPoints[19];
for( i = 0; i < HAND_POINTS; i++ )
{
scrHandPoints[i].x = (s_logHandPoints[i*2 ] * clientSize.x) / 1024;
scrHandPoints[i].y = (s_logHandPoints[i*2+1] * clientSize.x) / 1024/*not:768*/;
}
// draw the hands
long intensity = 42+light;
if( intensity < 70 ) intensity = 70;
if( intensity > 255 ) intensity = 255;
m_pen.SetColour(intensity, intensity, intensity);
dc.SetPen(m_pen);
for( i = 0; i < MAX_HANDS; i++ )
{
dc.DrawLines(HAND_POINTS, scrHandPoints,
(m_logHandsPos[i].x * clientSize.x) / 1024,
offset + (((m_logHandsPos[i].y * clientSize.y) / 768) - volume/m_logHandRnd[i]));
}
}
// Draws a line between (x1,y1) - (x2,y2) with a start thickness of t1
void DrawGLThickLine( float x1, float y1, float x2, float y2, wxPen pen, bool b_hiqual )
{
#ifdef ocpnUSE_GL
float angle = atan2f( y2 - y1, x2 - x1 );
float t1 = pen.GetWidth();
float t2sina1 = t1 / 2 * sinf( angle );
float t2cosa1 = t1 / 2 * cosf( angle );
glBegin( GL_TRIANGLES );
// n.b. The dwxDash interpretation for GL only allows for 2 elements in the dash table.
// The first is assumed drawn, second is assumed space
wxDash *dashes;
int n_dashes = pen.GetDashes( &dashes );
if( n_dashes ) {
float lpix = sqrtf( powf( (float) (x1 - x2), 2) + powf( (float) (y1 - y2), 2) );
float lrun = 0.;
float xa = x1;
float ya = y1;
float ldraw = t1 * dashes[0];
float lspace = t1 * dashes[1];
while( lrun < lpix ) {
// Dash
float xb = xa + ldraw * cosf( angle );
float yb = ya + ldraw * sinf( angle );
if( ( lrun + ldraw ) >= lpix ) // last segment is partial draw
{
xb = x2;
yb = y2;
}
glVertex2f( xa + t2sina1, ya - t2cosa1 );
glVertex2f( xb + t2sina1, yb - t2cosa1 );
glVertex2f( xb - t2sina1, yb + t2cosa1 );
glVertex2f( xb - t2sina1, yb + t2cosa1 );
glVertex2f( xa - t2sina1, ya + t2cosa1 );
glVertex2f( xa + t2sina1, ya - t2cosa1 );
xa = xb;
ya = yb;
lrun += ldraw;
// Space
xb = xa + lspace * cos( angle );
yb = ya + lspace * sin( angle );
xa = xb;
ya = yb;
lrun += lspace;
}
} else {
glVertex2f( x1 + t2sina1, y1 - t2cosa1 );
glVertex2f( x2 + t2sina1, y2 - t2cosa1 );
glVertex2f( x2 - t2sina1, y2 + t2cosa1 );
glVertex2f( x2 - t2sina1, y2 + t2cosa1 );
glVertex2f( x1 - t2sina1, y1 + t2cosa1 );
glVertex2f( x1 + t2sina1, y1 - t2cosa1 );
/* wx draws a nice rounded end in dc mode, so replicate
this for opengl mode, should this be done for the dashed mode case? */
if(pen.GetCap() == wxCAP_ROUND) {
DrawEndCap( x1, y1, t1, angle);
DrawEndCap( x2, y2, t1, angle + M_PI);
}
}
glEnd();
#endif
}
void SjOscRotor::Draw(wxDC& dc, const wxSize& clientSize, bool otherRunning, bool newTitle, long volume, long light)
{
if( m_mode == ROTOR_MODE_NOP )
{
m_pause--;
if( (m_pause <= 0 && !otherRunning) ) // about once in two minutes
{
m_mode = ROTOR_MODE_FADEIN;
m_logCenterX = SjTools::Rand(100);
m_logCenterY = SjTools::Rand(100);
m_logColour = 0;
m_delta = 0;
m_logDo = (10000 + SjTools::Rand(50000)) / SLEEP_MS; // 10-60 seconds
m_pause = SjTools::Rand(ROTOR_SLEEP_MS/SLEEP_MS);
m_followVolume = SjTools::Rand(2)==0;
}
return;
}
else if( m_mode == ROTOR_MODE_FADEIN )
{
m_logColour++;
long intensity = m_logColour;
if( light > intensity ) intensity = light;
m_pen.SetColour(intensity, intensity, intensity);
if( m_logColour == 255 )
{
m_pen.SetColour(255, 255, 255);
m_mode = ROTOR_MODE_DO;
}
}
else if( m_mode == ROTOR_MODE_DO )
{
m_logDo--;
if( m_logDo <= 0 || newTitle || otherRunning )
{
m_logDo = 0;
m_mode = ROTOR_MODE_FADEOUT;
if( newTitle || otherRunning )
{
m_mode = ROTOR_MODE_FADEOUTFAST;
if( SjTools::Rand(2) == 0 && !otherRunning )
{
m_pause = 0;
}
}
}
}
else if( m_mode == ROTOR_MODE_FADEOUT || m_mode == ROTOR_MODE_FADEOUTFAST )
{
m_logColour -= m_mode == ROTOR_MODE_FADEOUT? 1 : 3;
if( m_logColour < 0 ) m_logColour = 0;
long intensity = m_logColour;
if( light > intensity ) intensity = light;
m_pen.SetColour(intensity, intensity, intensity);
if( m_logColour == 0 )
{
m_mode = ROTOR_MODE_NOP;
}
}
if( m_followVolume )
{
double add = 0.001*volume;
if( add < 0.005 ) add = 0.005;
m_delta += add;
}
else
{
m_delta += 0.01;
}
if( m_delta >= PI )
{
m_delta -= PI;
}
int centerx = (clientSize.x*m_logCenterX) / 100,
centery = (clientSize.y*m_logCenterY) / 150/*not:100 - center is not in the lower part*/;
int radius = (clientSize.x+clientSize.y)*2;
dc.SetPen(m_pen);
dc.DrawLine(centerx+sin(m_delta )*radius, centery+cos(m_delta )*radius,
centerx+sin(m_delta+PI )*radius, centery+cos(m_delta+PI )*radius);
dc.DrawLine(centerx+sin(m_delta+PI/2 )*radius, centery+cos(m_delta+PI/2 )*radius,
centerx+sin(m_delta+PI/2+PI )*radius, centery+cos(m_delta+PI/2+PI )*radius);
}
// Draws thick lines from triangles
void DrawGLThickLines( int n, wxPoint points[],wxCoord xoffset,
wxCoord yoffset, wxPen pen, bool b_hiqual )
{
#ifdef ocpnUSE_GL
if(n < 2)
return;
/* for dashed case, for now just draw thick lines */
wxDash *dashes;
if( pen.GetDashes( &dashes ) )
{
wxPoint p0 = points[0];
for( int i = 1; i < n; i++ ) {
DrawGLThickLine( p0.x + xoffset, p0.y + yoffset, points[i].x + xoffset,
points[i].y + yoffset, pen, b_hiqual );
p0 = points[i];
}
return;
}
/* cull zero segments */
wxPoint *cpoints = new wxPoint[n];
cpoints[0] = points[0];
int c = 1;
for( int i = 1; i < n; i++ ) {
if(points[i].x != points[i-1].x || points[i].y != points[i-1].y)
cpoints[c++] = points[i];
}
/* nicer than than rendering each segment separately, this is because thick
line segments drawn as rectangles which have different angles have
rectangles which overlap and also leave a gap.
This code properly calculates vertexes for adjoining segments */
float t1 = pen.GetWidth();
float x0 = cpoints[0].x, y0 = cpoints[0].y, x1 = cpoints[1].x, y1 = cpoints[1].y;
float a0 = atan2f( y1 - y0, x1 - x0 );
// It is also possible to use triangle strip, (and triangle fan for endcap)
// to reduce vertex count.. is it worth it?
glBegin( GL_TRIANGLES );
float t2sina0 = t1 / 2 * sinf( a0 );
float t2cosa0 = t1 / 2 * cosf( a0 );
for( int i = 1; i < c; i++ ) {
float x2, y2;
float a1;
if(i < c - 1) {
x2 = cpoints[i + 1].x, y2 = cpoints[i + 1].y;
a1 = atan2f( y2 - y1, x2 - x1 );
} else {
x2 = x1, y2 = y1;
a1 = a0;
}
float aa = (a0 + a1) / 2;
float diff = fabsf(a0 - a1);
if(diff > M_PI)
diff -= 2 * (float)M_PI;
float rad = t1 / 2 / wxMax(cosf(diff / 2), .4);
float t2sina1 = rad * sinf( aa );
float t2cosa1 = rad * cosf( aa );
glVertex2f( x1 + t2sina1, y1 - t2cosa1 );
glVertex2f( x1 - t2sina1, y1 + t2cosa1 );
glVertex2f( x0 + t2sina0, y0 - t2cosa0 );
glVertex2f( x0 - t2sina0, y0 + t2cosa0 );
glVertex2f( x0 + t2sina0, y0 - t2cosa0 );
float dot = t2sina0 * t2sina1 + t2cosa0 * t2cosa1;
if(dot > 0)
glVertex2f( x1 - t2sina1, y1 + t2cosa1 );
else
glVertex2f( x1 + t2sina1, y1 - t2cosa1 );
x0 = x1, x1 = x2;
y0 = y1, y1 = y2;
a0 = a1;
t2sina0 = t2sina1, t2cosa0 = t2cosa1;
}
if(pen.GetCap() == wxCAP_ROUND) {
DrawEndCap( x0, y0, t1, a0);
DrawEndCap( x0, y0, t1, a0 + M_PI);
}
glEnd();
glPopAttrib();
delete [] cpoints;
#endif
}
wxString xsPenPropIO::ToString(wxPen value)
{
return wxString::Format(wxT("%s %d %d"), xsColourPropIO::ToString(value.GetColour()).c_str(), value.GetWidth(), value.GetStyle());
}
void wxDC::SetPen(const wxPen& pen)
{
m_pen = pen.Ok() ? pen : DEFAULT_PEN;
SelectColour(m_pen.GetColour());
}
