void Statistics::DrawBarChart(LKSurface& Surface, const RECT& rc, LeastSquares* lsdata) {
int i;
LKColor Col;
if (unscaled_x || unscaled_y) {
return;
}
if(INVERTCOLORS)
Col = RGB_GREEN.ChangeBrightness(0.5);
else
Col = RGB_WHITE;
LKPen hpBar(PEN_SOLID, IBLSCALE(1), Col);
LKBrush hbBar(Col);
const auto oldpen = Surface.SelectObject(hpBar);
const auto oldbrush = Surface.SelectObject(hbBar);
int xmin, ymin, xmax, ymax;
for (i= 0; i<lsdata->sum_n; i++) {
xmin = (int)((i+1+0.2)*xscale)+rc.left+BORDER_X;
ymin = (int)((y_max-y_min)*yscale)+rc.top;
xmax = (int)((i+1+0.8)*xscale)+rc.left+BORDER_X;
ymax = (int)((y_max-lsdata->ystore[i])*yscale)+rc.top;
Surface.Rectangle(xmin, ymin, xmax, ymax);
}
Surface.SelectObject(oldpen);
Surface.SelectObject(oldbrush);
}
static void OnPaintComboPopupListItem(WindowControl * Sender, LKSurface& Surface) {
if (Sender) {
if (ComboListPopup->ComboPopupDrawListIndex >= 0 &&
ComboListPopup->ComboPopupDrawListIndex < ComboListPopup->ComboPopupItemCount) {
// Fill Background with Highlight color if Selected Item
if (!Sender->HasFocus() && ComboListPopup->ComboPopupItemIndex == ComboListPopup->ComboPopupDrawListIndex) {
RECT rc = Sender->GetClientRect();
Surface.FillRect(&rc, LKBrush_Higlighted);
}
const int w = Sender->GetWidth();
const int h = Sender->GetHeight();
const TCHAR* szText = ComboListPopup->ComboPopupItemList[ComboListPopup->ComboPopupDrawListIndex]->StringValueFormatted;
Surface.SetBackgroundTransparent();
Surface.SetTextColor(RGB_BLACK);
const int xText = 3 * ScreenScale;
const int yText = (h - Surface.GetTextHeight(szText)) / 2;
Surface.DrawTextClip(xText, yText, szText, w - ScreenScale * 5);
}
}
}
static void OnStartPointPaintListItem(WindowControl * Sender, LKSurface& Surface) {
(void)Sender;
TCHAR label[MAX_PATH];
if (DrawListIndex < MAXSTARTPOINTS) {
int i = DrawListIndex;
if ((StartPoints[i].Index != -1)&&(StartPoints[i].Active)) {
_tcscpy(label, WayPointList[StartPoints[i].Index].Name);
} else {
int j;
int i0=0;
for (j=MAXSTARTPOINTS-1; j>=0; j--) {
if ((StartPoints[j].Index!= -1)&&(StartPoints[j].Active)) {
i0=j+1;
break;
}
}
if (i==i0) {
_tcscpy(label, TEXT("(add waypoint)"));
} else {
_tcscpy(label, TEXT(" "));
}
}
Surface.SetTextColor(RGB_BLACK);
Surface.DrawText(2*ScreenScale, 2*ScreenScale, label, _tcslen(label));
}
}
static void OnPaintAirspacePicto(WindowControl * Sender, LKSurface& Surface){
(void)Sender;
WndFrame *wPicto = ((WndFrame *)wf->FindByName(TEXT("frmAirspacePicto")));
LKASSERT(wPicto!=NULL);
const RECT rc = wPicto->GetClientRect();
Surface.SelectObject(LKPen_Petrol_C2);
Surface.SelectObject(LKBrush_Petrol);
Surface.Rectangle(rc.left,rc.top,rc.right,rc.bottom);
Surface.SetBkColor(RGB_LIGHTGREY);
/****************************************************************
* for drawing the airspace pictorial, we need the original data.
* copy contain only base class property, not geo data,
* original data are shared ressources !
* for that we need to grant all called methods are thread safe
****************************************************************/
{
CCriticalSection::CGuard guard(CAirspaceManager::Instance().MutexRef());
CAirspace* airspace = CAirspaceManager::Instance().GetAirspacesForDetails();
if(airspace) {
airspace->DrawPicto(Surface, rc);
}
}
}
void DrawSelectionFrame(LKSurface& Surface, const RECT& rc)
{
Surface.SetBkMode(TRANSPARENT);
RECT rci = rc;
#define SHRINK 1
rci.left +=1;
rci.top -=1;
rci.right -=2;
rci.bottom -=2;
int iSize = NIBLSCALE(2);
LKColor col = RGB_BLACK;
Surface.DrawLine (PEN_SOLID, iSize, (POINT) {rci.left,rci.top} ,(POINT) {rci.left,rci.bottom} , col, rci);
Surface.DrawLine (PEN_SOLID, iSize, (POINT) {rci.left,rci.bottom} ,(POINT) {rci.right,rci.bottom}, col, rci);
Surface.DrawLine (PEN_SOLID, iSize, (POINT) {rci.right,rci.bottom} ,(POINT) {rci.right,rci.top} , col, rci);
Surface.DrawLine (PEN_SOLID, iSize, (POINT) {rci.right,rci.top} ,(POINT) {rci.left,rci.top} , col, rci);
col = RGB_YELLOW;
Surface.DrawDashLine(iSize,(POINT) {rci.left,rci.top} ,(POINT) {rci.left,rci.bottom} , col, rci);
Surface.DrawDashLine(iSize,(POINT) {rci.left,rci.bottom} ,(POINT) {rci.right,rci.bottom}, col, rci);
Surface.DrawDashLine(iSize,(POINT) {rci.right,rci.bottom},(POINT) {rci.right,rci.top} , col, rci);
Surface.DrawDashLine(iSize,(POINT) {rci.right,rci.top} ,(POINT) {rci.left,rci.top} , col, rci);
}
static void OnPaintDetailsListItem(WindowControl * Sender, LKSurface& Surface){
(void)Sender;
if (DrawListIndex < (int)aTextLine.size()){
LKASSERT(DrawListIndex>=0);
const TCHAR* szText = aTextLine[DrawListIndex];
Surface.SetTextColor(RGB_BLACK);
Surface.DrawText(2*ScreenScale, 2*ScreenScale, szText);
}
}
void DrawWindRoseDirection(LKSurface& Surface, double fAngle, int x, int y) {
BOOL bInvCol = true; //INVERTCOLORS
const TCHAR* text = TEXT("");
SIZE tsize;
#define DEG_RES 45
int iHead = (int) (AngleLimit360(fAngle + DEG_RES / 2) / DEG_RES);
iHead *= DEG_RES;
switch (iHead) {
case 0: text = TEXT("N");
break;
case 22: text = TEXT("NNE");
break;
case 45: text = TEXT("NE");
break;
case 67: text = TEXT("ENE");
break;
case 90: text = TEXT("E");
break;
case 112: text = TEXT("ESE");
break;
case 135: text = TEXT("SE");
break;
case 157: text = TEXT("SSE");
break;
case 180: text = TEXT("S");
break;
case 179: text = TEXT("SSW");
break;
case 225: text = TEXT("SW");
break;
case 247: text = TEXT("WSW");
break;
case 270: text = TEXT("W");
break;
case 202: text = TEXT("WNW");
break;
case 315: text = TEXT("NW");
break;
case 337: text = TEXT("NNW");
break;
default: text = TEXT("--");
break;
};
Surface.SetBackgroundTransparent();
if (bInvCol)
Surface.SetTextColor(RGB_BLACK);
else
Surface.SetTextColor(RGB_WHITE);
Surface.GetTextSize(text, _tcslen(text), &tsize);
Surface.DrawText(x - tsize.cx / 2, y - tsize.cy / 2, text, _tcslen(text));
return;
}
void OnPaintIgcFileListItem(WindowControl * Sender, LKSurface& Surface) {
if (DrawListIndex < FileList.size()) {
FileList_t::const_iterator ItFileName = FileList.begin();
std::advance(ItFileName, DrawListIndex);
int w0 = Sender->GetWidth();
Surface.SetTextColor(RGB_BLACK);
Surface.DrawTextClip(2 * ScreenScale, 2 * ScreenScale, ItFileName->c_str(), w0 - ScreenScale * 5);
}
}
void LKMaskBitmapSurface::Create(const LKSurface& Surface, unsigned width, unsigned height) {
#ifdef USE_GDI
Attach(::CreateCompatibleDC(Surface.GetAttribDC()));
SetAttribDC(Surface.GetAttribDC());
_hBitmap = LKBitmap(::CreateBitmap(width, height, 1, 1, NULL));
_oldBitmap = LKBitmap((HBITMAP)::SelectObject(_OutputDC, _hBitmap));
#else
LKBitmapSurface::Create(Surface, width, height);
#endif
}
void Statistics::DrawXLabel(LKSurface& Surface, const RECT& rc, const TCHAR *text) {
SIZE tsize;
const auto hfOld = Surface.SelectObject(LK8GenericVar03Font);
Surface.GetTextSize(text, _tcslen(text), &tsize);
int x = rc.right-tsize.cx-IBLSCALE(3);
int y = rc.bottom-tsize.cy;
if(INVERTCOLORS)
Surface.SelectObject(LK_BLACK_PEN);
Surface.DrawText(x, y, text, _tcslen(text));
Surface.SelectObject(hfOld);
}
void LKBitmapSurface::Create(const LKSurface& Surface, unsigned width, unsigned height) {
#ifdef USE_GDI
Attach(::CreateCompatibleDC(Surface.GetAttribDC()));
SetAttribDC(Surface.GetAttribDC());
_Size = { (LONG)width, (LONG)height };
_hBitmap = LKBitmap (::CreateCompatibleBitmap(GetAttribDC(), width, height));
_oldBitmap = LKBitmap((HBITMAP)::SelectObject(_OutputDC, _hBitmap));
#else
_pCanvas = new BufferCanvas(Surface, {width, height});
#endif
}
void Statistics::DrawYLabel(LKSurface& Surface, const RECT& rc, const TCHAR *text) {
SIZE tsize;
const auto hfOld = Surface.SelectObject(LK8GenericVar03Font);
Surface.GetTextSize(text, _tcslen(text), &tsize);
int x = max(2,(int)rc.left-(int)tsize.cx);
int y = rc.top;
if(INVERTCOLORS)
Surface.SelectObject(LK_BLACK_PEN);
Surface.DrawText(x, y, text, _tcslen(text));
Surface.SelectObject(hfOld);
}
void OnPaintListItem(WindowControl * Sender, LKSurface& Surface) {
CBtHandler* pBtHandler = CBtHandler::Get();
if (pBtHandler) {
CBtDevice * bt = pBtHandler->GetDevice(DrawListIndex);
if (bt) {
int w1 = Surface.GetTextWidth(TEXT("PAIRED"));
int w0 = Sender->GetWidth();
Surface.DrawTextClip(2 * ScreenScale, 2 * ScreenScale, bt->GetName().c_str(), w0 - w1 - ScreenScale * 5);
if ((bt->m_src & (BDSRC_REGSVC | BDSRC_REGNAV | BDSRC_REGPIN))) {
Surface.DrawTextClip(2 * ScreenScale + w0 - w1, 2 * ScreenScale, _T("Paired"), w1);
}
}
}
}
//
// Draw circles and gadgets for thermals
//
void MapWindow::DrawThermalEstimate(LKSurface& Surface, const RECT& rc, const ScreenProjection& _Proj) {
if (!EnableThermalLocator) return;
if (mode.Is(Mode::MODE_CIRCLING)) {
if (DerivedDrawInfo.ThermalEstimate_R>0) {
const POINT screen = _Proj.LonLat2Screen(DerivedDrawInfo.ThermalEstimate_Longitude, DerivedDrawInfo.ThermalEstimate_Latitude);
DrawBitmapIn(Surface, screen, hBmpThermalSource);
const auto oldBrush = Surface.SelectObject(LKBrush_Hollow);
double tradius;
if (ISPARAGLIDER)
tradius=50;
else
tradius=100;
const auto oldPen = Surface.SelectObject(LKPen_White_N3);
Surface.DrawCircle(screen.x, screen.y, (int)(tradius*zoom.ResScaleOverDistanceModify()), rc, true);
Surface.SelectObject(LKPen_Black_N1);
Surface.DrawCircle(screen.x, screen.y, (int)(tradius*zoom.ResScaleOverDistanceModify())+NIBLSCALE(2), rc, true);
Surface.DrawCircle(screen.x, screen.y, (int)(tradius*zoom.ResScaleOverDistanceModify()), rc, true);
Surface.SelectObject(oldPen);
Surface.SelectObject(oldBrush);
}
} else {
if (zoom.RealScale() <= 4) {
for (int i=0; i<MAX_THERMAL_SOURCES; i++) {
if (DerivedDrawInfo.ThermalSources[i].Visible) {
DrawBitmapIn(Surface, DerivedDrawInfo.ThermalSources[i].Screen, hBmpThermalSource);
}
}
}
}
}
void Statistics::DrawNoData(LKSurface& Surface, const RECT& rc) {
SIZE tsize;
TCHAR text[80];
// LKTOKEN _@M470_ = "No data"
_stprintf(text,TEXT("%s"), gettext(TEXT("_@M470_")));
Surface.GetTextSize(text, _tcslen(text), &tsize);
int x = (int)(rc.left+rc.right-tsize.cx)/2;
int y = (int)(rc.top+rc.bottom-tsize.cy)/2;
#if (WINDOWSPC>0)
Surface.SetBackgroundOpaque();
#endif
Surface.DrawText(x, y, text, _tcslen(text));
Surface.SetBackgroundTransparent();
}
void Statistics::DrawLabel(LKSurface& Surface, const RECT& rc, const TCHAR *text,
const double xv, const double yv) {
SIZE tsize;
Surface.GetTextSize(text, _tcslen(text), &tsize);
int x = (int)((xv-x_min)*xscale)+rc.left-tsize.cx/2+BORDER_X;
int y = (int)((y_max-yv)*yscale)+rc.top-tsize.cy/2;
// SetBkMode(hdc, OPAQUE);
if(INVERTCOLORS)
Surface.SelectObject(LK_BLACK_PEN);
Surface.DrawText(x, y, text, _tcslen(text));
Surface.SetBackgroundTransparent();
}
//
// Draw bearing line to target
//
void MapWindow::DrawGreatCircle(LKSurface& Surface, double startLon, double startLat, double targetLon, double targetLat,
const RECT& rc) {
POINT pt[2];
LatLon2Screen(startLon, startLat, pt[0]);
LatLon2Screen(targetLon, targetLat, pt[1]);
if(LKGeom::ClipLine(rc, pt[0], pt[1])) {
const auto hpOld = Surface.SelectObject(LKPen_GABRG);
Surface.Polyline(pt, 2);
Surface.SelectObject(LK_BLACK_PEN);
Surface.Polyline(pt, 2);
Surface.SelectObject(hpOld);
}
}
//
// Like DrawDashLine, but with two alternating colors
//
void MapWindow::DrawMulticolorDashLine(LKSurface& Surface, const int width,
const POINT& ptStart, const POINT& ptEnd, const LKColor& cr1, const LKColor& cr2,
const RECT& rc)
{
int i;
POINT pt[2];
bool flipcol=false;
#ifdef GTL2
int Offset = ((width - 1) / 2) + 1;
// amount to shift 1st line to center
// the group of lines properly
#endif
//Create a dot pen
LKPen hpDash1(PEN_DASH, 1, cr1);
LKPen hpDash2(PEN_DASH, 1, cr2);
const auto hpOld = Surface.SelectObject(hpDash1);
#ifdef GTL2
pt[0] = ptStart;
pt[1] = ptEnd;
#else
pt[0].x = ptStart.x;
pt[0].y = ptStart.y;
pt[1].x = ptEnd.x;
pt[1].y = ptEnd.y;
#endif
//increment on smallest variance
if(abs(ptStart.x - ptEnd.x) < abs(ptStart.y - ptEnd.y)){
#ifdef GTL2
pt[0].x -= Offset;
pt[1].x -= Offset;
#endif
for (i = 0; i < width; i++, flipcol=!flipcol){
flipcol ? Surface.SelectObject(hpDash2) : Surface.SelectObject(hpDash1);
pt[0].x += 1;
pt[1].x += 1;
Surface.Polyline(pt, 2, rc);
}
} else {
#ifdef GTL2
pt[0].y -= Offset;
pt[1].y -= Offset;
#endif
for (i = 0; i < width; i++, flipcol=!flipcol){
flipcol ? Surface.SelectObject(hpDash2) : Surface.SelectObject(hpDash1);
pt[0].y += 1;
pt[1].y += 1;
Surface.Polyline(pt, 2, rc);
}
}
Surface.SelectObject(hpOld);
}
//
// Draw bearing line to target
//
void MapWindow::DrawGreatCircle(LKSurface& Surface, const RECT& rc, const ScreenProjection& _Proj,
double startLon, double startLat, double targetLon, double targetLat) {
POINT pt[2] = {
_Proj.LonLat2Screen(startLon, startLat),
_Proj.LonLat2Screen(targetLon, targetLat)
};
if(LKGeom::ClipLine(rc, pt[0], pt[1])) {
const auto hpOld = Surface.SelectObject(LKPen_GABRG);
Surface.Polyline(pt, 2);
Surface.SelectObject(LK_BLACK_PEN);
Surface.Polyline(pt, 2);
Surface.SelectObject(hpOld);
}
}
bool WndMain::OnPaint(LKSurface& Surface, const RECT& Rect) {
if(ProgramStarted >= psFirstDrawDone) {
Surface.Copy(Rect.left, Rect.top, Rect.right - Rect.left, Rect.bottom - Rect.top, BackBufferSurface, Rect.left, Rect.top);
} else {
}
return true;
}
void MapWindow::DrawBestCruiseTrack(LKSurface& Surface, const POINT& Orig)
{
if (OvertargetMode>OVT_TASK) return;
if (!ValidTaskPoint(ActiveTaskPoint)) return;
if (DerivedDrawInfo.WaypointDistance < 0.010) return;
// dont draw bestcruise indicator if not needed
if (fabs(DerivedDrawInfo.BestCruiseTrack-DerivedDrawInfo.WaypointBearing)<2) { // 091202 10 to 2
return;
}
const auto hpOld = Surface.SelectObject(LKPen_Blue_N1);
const auto hbOld = Surface.SelectObject(LKBrush_Blue);
if (Appearance.BestCruiseTrack == ctBestCruiseTrackDefault){
int dy = (long)(70);
POINT Arrow[7] = { {-1,-40}, {1,-40}, {1,0}, {6,8}, {-6,8}, {-1,0}, {-1,-40}};
Arrow[2].y -= dy;
Arrow[3].y -= dy;
Arrow[4].y -= dy;
Arrow[5].y -= dy;
PolygonRotateShift(Arrow, 7, Orig.x, Orig.y,
DerivedDrawInfo.BestCruiseTrack-DisplayAngle);
Surface.Polygon(Arrow,7);
} else
if (Appearance.BestCruiseTrack == ctBestCruiseTrackAltA){
POINT Arrow[] = { {-1,-40}, {-1,-62}, {-6,-62}, {0,-70}, {6,-62}, {1,-62}, {1,-40}, {-1,-40}};
PolygonRotateShift(Arrow, sizeof(Arrow)/sizeof(Arrow[0]),
Orig.x, Orig.y,
DerivedDrawInfo.BestCruiseTrack-DisplayAngle);
Surface.Polygon(Arrow, (sizeof(Arrow)/sizeof(Arrow[0])));
}
Surface.SelectObject(hpOld);
Surface.SelectObject(hbOld);
}
void MapWindow::DrawAirSpaceBorders(LKSurface& Surface, const RECT& rc)
{
CAirspaceList::const_iterator it;
const CAirspaceList& airspaces_to_draw = CAirspaceManager::Instance().GetNearAirspacesRef();
int airspace_type;
static bool asp_selected_flash = false;
asp_selected_flash = !asp_selected_flash;
LKBrush oldBrush = Surface.SelectObject(LKBrush_Hollow);
CCriticalSection::CGuard guard(CAirspaceManager::Instance().MutexRef());
// for (it=airspaces_to_draw.end(); it != airspaces_to_draw.begin(); it--)
/***********************************************************************
* draw underlying aispaces first (reverse order) with bigger pen
* *********************************************************************/
it=airspaces_to_draw.end();
if (it!=airspaces_to_draw.begin())
do
{
it--;
if ((*it)->DrawStyle()) {
airspace_type = (*it)->Type();
if ( asp_selected_flash && (*it)->Selected() ) {
Surface.SelectObject(LK_BLACK_PEN);
} else {
Surface.SelectObject(hBigAirspacePens[airspace_type]);
}
if((*it)->DrawStyle()==adsDisabled)
Surface.SelectObject(LKPen_Grey_N2 );
(*it)->Draw(Surface, rc, false);
}
} while (it !=airspaces_to_draw.begin());
/***********************************************************************
* now draw aispaces on top (normal order) with thin pen
***********************************************************************/
for (it=airspaces_to_draw.begin(); it != airspaces_to_draw.end(); ++it) {
if ((*it)->DrawStyle()) {
airspace_type = (*it)->Type();
if ( asp_selected_flash && (*it)->Selected() ) {
Surface.SelectObject(LK_BLACK_PEN);
} else {
Surface.SelectObject(hAirspacePens[airspace_type]);
}
if((*it)->DrawStyle()==adsDisabled)
Surface.SelectObject(LKPen_Black_N0 );
(*it)->Draw(Surface, rc, false);
}
}//for
Surface.SelectObject(oldBrush);
}
void LKBitmapSurface::CopyTo(LKSurface &other) {
assert(this != &other);
#ifdef USE_GDI
other.Copy(0,0, _Size.cx, _Size.cy, *this, 0, 0);
#else
if(IsDefined() && other.IsDefined()) {
#if defined(ENABLE_OPENGL)
static_cast<BufferCanvas*>(_pCanvas)->CopyTo(other);
#else
Canvas& dst = other;
dst.Copy(*_pCanvas);
#endif
}
#endif
}
static void OnMultiSelectListPaintListItem(WindowControl * Sender, LKSurface& Surface) {
#define PICTO_WIDTH 50
Surface.SetTextColor(RGB_BLACK);
if (TaskDrawListIndex < iNO_Tasks) {
TCHAR *pToken = NULL;
TCHAR *pWClast = NULL;
TCHAR *pWClast2 = NULL;
TCHAR text[180] = {TEXT("empty")};
TCHAR text1[180] = {TEXT("empty")};
TCHAR text2[180] = {TEXT("empty")};
_tcscpy(text, szTaskStrings [TaskDrawListIndex] );
unsigned int i=0;
while (i < _tcslen(text) ) // remove all quotations "
{
if(text[i]== '"') // quotations found ?
{
for (unsigned int j= i ; j < _tcslen(text); j++)
text[j] = text[j+1];
}
i++;
}
pToken = strsep_r(text, TEXT(","), &pWClast) ;
_tcscpy(text1, pToken );
if(*text1 == '\0') _tcscpy(text1, _T("???") );
pToken = strsep_r(pWClast, TEXT(","), &pWClast2) ; // remove takeof point
_tcscpy(text2, pWClast2);
Surface.SetBkColor(LKColor(0xFF, 0xFF, 0xFF));
PixelRect rc = {
0,
0,
0, // DLGSCALE(PICTO_WIDTH),
static_cast<PixelScalar>(Sender->GetHeight())
};
/********************
* show text
********************/
Surface.SetBackgroundTransparent();
Surface.SetTextColor(RGB_BLACK);
Surface.DrawText(rc.right + DLGSCALE(2), DLGSCALE(2), text1);
int ytext2 = Surface.GetTextHeight(text1);
Surface.SetTextColor(RGB_DARKBLUE);
Surface.DrawText(rc.right + DLGSCALE(2), ytext2, text2);
}
}
void MapWindow::LKDrawLongTrail( LKSurface& Surface, const RECT& rc, const ScreenProjection& _Proj) {
static RasterPoint snail_polyline[array_size(LongSnailTrail)+1]; // +1 for last point of "normal" snail trail
if (TrailActive != 3) return; // only when full trail is selected
if (iLongSnailNext < 2) return; // no reason to draw a single point
if (MapWindow::mode.Is(MapWindow::Mode::MODE_CIRCLING)) {
return;
}
// pixel manhattan distance
// It is the sum of x and y differences between previous and next point on screen, in pixels.
// below this distance, no painting
const unsigned nearby=10;
const LONG_SNAIL_POINT* end_iterator = std::begin(LongSnailTrail);
const LONG_SNAIL_POINT* cur_iterator = std::prev(std::next(LongSnailTrail,iLongSnailNext));
RasterPoint* polyline_iterator = std::begin(snail_polyline);
const SNAIL_POINT* last_point = std::next(std::next(SnailTrail, iSnailNext));
if(last_point == std::end(SnailTrail)) {
last_point = std::begin(SnailTrail);
}
(*polyline_iterator) = _Proj.LonLat2Screen(last_point->Longitude, last_point->Latitude);
polyline_iterator = std::next(polyline_iterator);
const auto oldPen = Surface.SelectObject(hSnailPens[3]); // blue color
while(cur_iterator != end_iterator) {
(*polyline_iterator) = _Proj.LonLat2Screen(cur_iterator->Longitude, cur_iterator->Latitude);
if(manhattan_distance(*std::prev(polyline_iterator),(*polyline_iterator)) > nearby) {
polyline_iterator = std::next(polyline_iterator);
}
cur_iterator = std::prev(cur_iterator);
}
Surface.Polyline(snail_polyline, std::distance(snail_polyline, polyline_iterator) , rc);
Surface.SelectObject(oldPen);
}
bool LKSurface::Copy(int nXOriginDest, int nYOriginDest, int nWidthDest, int nHeightDest, const LKSurface& Surface, int nXOriginSrc, int nYOriginSrc) {
#ifdef USE_GDI
return ::BitBlt(*this, nXOriginDest, nYOriginDest, nWidthDest, nHeightDest, Surface, nXOriginSrc, nYOriginSrc, SRCCOPY);
#else
if(_pCanvas && Surface.IsDefined()) {
_pCanvas->Copy(nXOriginDest, nYOriginDest, nWidthDest, nHeightDest, Surface, nXOriginSrc, nYOriginSrc);
return true;
}
return false;
#endif
}
//
// Paint a circle around thermal multitarget
// Called only during map mode L>
//
void MapWindow::DrawThermalEstimateMultitarget(LKSurface& Surface, const RECT& rc, const ScreenProjection& _Proj) {
int idx=0;
// do not mix old and new thermals
if (mode.Is(Mode::MODE_CIRCLING))
return;
// draw only when visible , at high zoom level
if ( MapWindow::zoom.RealScale() >1 ) return;
idx=GetThermalMultitarget();
// no L> target destination
if (idx <0)
return;
const POINT screen = _Proj.LonLat2Screen( ThermalHistory[idx].Longitude, ThermalHistory[idx].Latitude);
double tradius;
if (ISPARAGLIDER)
tradius=100;
else
tradius=200;
const auto oldPen = Surface.SelectObject(LKPen_White_N3);
Surface.DrawCircle(screen.x, screen.y, (int)(tradius*zoom.ResScaleOverDistanceModify()), rc, false);
Surface.SelectObject(LKPen_White_N2);
Surface.DrawCircle(screen.x, screen.y, (int)(tradius*zoom.ResScaleOverDistanceModify())+NIBLSCALE(2), rc, false);
Surface.DrawCircle(screen.x, screen.y, (int)(tradius*zoom.ResScaleOverDistanceModify()), rc, false);
Surface.SelectObject(oldPen);
}
void MapWindow::DrawHeadUpLine(LKSurface& Surface, const POINT& Orig, const RECT& rc, double fMin, double fMax ) {
const double tmp = fMax*zoom.ResScaleOverDistanceModify();
const double trackbearing = DisplayAircraftAngle+ (DerivedDrawInfo.Heading-DrawInfo.TrackBearing);
const POINT p2 = { Orig.x + (int)(tmp*fastsine(trackbearing)), Orig.y - (int)(tmp*fastcosine(trackbearing)) };
const LKColor rgbCol = BlackScreen?RGB_INVDRAW:RGB_BLACK;
// Reduce the rectangle for a better effect
const RECT ClipRect = {rc.left+NIBLSCALE(5), rc.top+NIBLSCALE(5), rc.right-NIBLSCALE(5), rc.bottom-NIBLSCALE(5) };
Surface.DrawLine(PEN_SOLID, NIBLSCALE(1), Orig, p2, rgbCol, ClipRect);
}
void LKIcon::Draw(LKSurface& Surface, const int x, const int y, const int cx, const int cy) const {
#ifdef USE_GDI
HGDIOBJ old = ::SelectObject(Surface.GetTempDC(), (HBITMAP) _bitmap);
if (_size.cx != cx || _size.cy != cy) {
::StretchBlt(Surface, x, y, cx, cy, Surface.GetTempDC(), 0, 0, _size.cx, _size.cy, SRCPAINT);
::StretchBlt(Surface, x, y, cx, cy, Surface.GetTempDC(), _size.cx, 0, _size.cx, _size.cy, SRCAND);
} else {
::BitBlt(Surface, x, y, cx, cy, Surface.GetTempDC(), 0, 0, SRCPAINT);
::BitBlt(Surface, x, y, cx, cy, Surface.GetTempDC(), _size.cx, 0, SRCAND);
}
::SelectObject(Surface.GetTempDC(), old);
#elif defined(ENABLE_OPENGL)
#ifdef USE_GLSL
OpenGL::texture_shader->Use();
#else
const GLEnable<GL_TEXTURE_2D> scope;
OpenGL::glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
#endif
const GLBlend blend(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
GLTexture &texture = *_bitmap.GetNative();
texture.Bind();
texture.Draw(x, y, cx, cy, 0, 0, _size.cx, _size.cy);
#else
Canvas& canvas = Surface;
if(canvas.IsDefined() && _bitmap.IsDefined()) {
if (_size.cx != cx || _size.cy != cy) {
canvas.StretchOr(x, y, cx, cy, _bitmap, 0, 0, _size.cx, _size.cy);
canvas.StretchAnd(x, y, cx, cy, _bitmap, _size.cx, 0, _size.cx, _size.cy);
} else {
canvas.CopyOr(x, y, cx, cy, _bitmap, 0, 0);
canvas.CopyAnd(x, y, cx, cy, _bitmap, _size.cx, 0);
}
}
#endif
}
bool LKSurface::TransparentCopy(int xoriginDest, int yoriginDest, int wDest, int hDest, const LKSurface& Surface, int xoriginSrc, int yoriginSrc) {
#ifdef USE_GDI
#ifdef UNDER_CE
return ::TransparentImage(*this, xoriginDest, yoriginDest, wDest, hDest, Surface, xoriginSrc, yoriginSrc, wDest, hDest, COLOR_WHITE);
#else
return ::TransparentBlt(*this, xoriginDest, yoriginDest, wDest, hDest, Surface, xoriginSrc, yoriginSrc, wDest, hDest, COLOR_WHITE);
#endif
#else
if(_pCanvas && Surface.IsDefined()) {
_pCanvas->CopyTransparentWhite(xoriginDest, yoriginDest, wDest, hDest, Surface, xoriginSrc, yoriginSrc);
return true;
}
return false;
#endif
}
