void Statistics::StyleLine(HDC hdc, POINT l1, POINT l2,
int Style) {
POINT line[2];
line[0] = l1;
line[1] = l2;
switch (Style) {
case STYLE_BLUETHIN:
DrawDashLine(hdc, 1,
l1,
l2,
RGB(0,0,255));
break;
case STYLE_REDTHICK:
DrawDashLine(hdc, 3,
l1,
l2,
RGB(200,50,50));
break;
case STYLE_DASHGREEN:
DrawDashLine(hdc, 2,
line[0],
line[1],
RGB(0,255,0));
break;
case STYLE_MEDIUMBLACK:
SelectObject(hdc, GetStockObject(BLACK_PEN));
Polyline(hdc, line, 2);
break;
case STYLE_THINDASHPAPER:
DrawDashLine(hdc, 1,
l1,
l2,
RGB(0xf0,0xf0,0xb0));
break;
default:
break;
}
}
void MapWindow::DrawTask(HDC hdc, RECT rc, const POINT &Orig_Aircraft) {
int i;
double tmp;
COLORREF whitecolor = RGB_WHITE;
COLORREF origcolor = SetTextColor(hDCTemp, whitecolor);
HPEN oldpen = 0;
HBRUSH oldbrush = 0;
static short size_tasklines=0;
if (DoInit[MDI_DRAWTASK]) {
switch (ScreenSize) {
case ss480x272:
case ss272x480:
case ss320x240:
case ss240x320:
size_tasklines=NIBLSCALE(4);
break;
default:
size_tasklines=NIBLSCALE(3);
break;
}
DoInit[MDI_DRAWTASK]=false;
}
if (!WayPointList) return;
oldpen = (HPEN) SelectObject(hdc, hpStartFinishThick);
oldbrush = (HBRUSH) SelectObject(hdc, GetStockObject(HOLLOW_BRUSH));
LockTaskData(); // protect from external task changes
for (i = 1; ValidTaskPoint(i); i++) {
if (!ValidTaskPoint(i + 1)) { // final waypoint
if (ActiveWayPoint > 1 || !ValidTaskPoint(2)) {
// only draw finish line when past the first
// waypoint. FIXED 110307: or if task is with only 2 tps
DrawStartEndSector(hdc, rc, Task[i].Start, Task[i].End, Task[i].Index, FinishLine, FinishRadius);
}
} else { // normal sector
if (AATEnabled != TRUE) {
//_DrawLine(hdc, PS_DASH, NIBLSCALE(3), WayPointList[Task[i].Index].Screen, Task[i].Start, RGB_PETROL, rc);
//_DrawLine(hdc, PS_DASH, NIBLSCALE(3), WayPointList[Task[i].Index].Screen, Task[i].End, RGB_PETROL, rc);
// DrawDashLine(hdc, size_tasklines, WayPointList[Task[i].Index].Screen, Task[i].Start, RGB_PETROL, rc);
// DrawDashLine(hdc, size_tasklines, WayPointList[Task[i].Index].Screen, Task[i].End, RGB_PETROL, rc);
}
int Type = 0;
double Radius = 0.;
GetTaskSectorParameter(i, &Type, &Radius);
switch (Type) {
case CIRCLE:
tmp = Radius * zoom.ResScaleOverDistanceModify();
Circle(hdc,
WayPointList[Task[i].Index].Screen.x,
WayPointList[Task[i].Index].Screen.y,
(int) tmp, rc, false, false);
break;
case SECTOR:
tmp = Radius * zoom.ResScaleOverDistanceModify();
Segment(hdc,
WayPointList[Task[i].Index].Screen.x,
WayPointList[Task[i].Index].Screen.y, (int) tmp, rc,
Task[i].AATStartRadial - DisplayAngle,
Task[i].AATFinishRadial - DisplayAngle);
break;
case DAe:
if (!AATEnabled) { // this Type exist only if not AAT task
// JMW added german rules
tmp = 500 * zoom.ResScaleOverDistanceModify();
Circle(hdc,
WayPointList[Task[i].Index].Screen.x,
WayPointList[Task[i].Index].Screen.y,
(int) tmp, rc, false, false);
tmp = 10e3 * zoom.ResScaleOverDistanceModify();
Segment(hdc,
WayPointList[Task[i].Index].Screen.x,
WayPointList[Task[i].Index].Screen.y, (int) tmp, rc,
Task[i].AATStartRadial - DisplayAngle,
Task[i].AATFinishRadial - DisplayAngle);
}
break;
case LINE:
if (!AATEnabled) { // this Type exist only if not AAT task
if(ISGAAIRCRAFT) {
POINT start,end;
double rotation=AngleLimit360(Task[i].Bisector-DisplayAngle);
int length=14*ScreenScale; //Make intermediate WP lines always of the same size independent by zoom level
start.x=WayPointList[Task[i].Index].Screen.x+(long)(length*fastsine(rotation));
start.y=WayPointList[Task[i].Index].Screen.y-(long)(length*fastcosine(rotation));
rotation=Reciprocal(rotation);
end.x=WayPointList[Task[i].Index].Screen.x+(long)(length*fastsine(rotation));
end.y=WayPointList[Task[i].Index].Screen.y-(long)(length*fastcosine(rotation));
_DrawLine(hdc, PS_SOLID, NIBLSCALE(3), start, end, taskcolor, rc);
} else _DrawLine(hdc, PS_SOLID, NIBLSCALE(3), Task[i].Start, Task[i].End, taskcolor, rc);
}
break;
case CONE:
tmp = Radius * zoom.ResScaleOverDistanceModify();
int center_x = WayPointList[Task[i].Index].Screen.x;
int center_y = WayPointList[Task[i].Index].Screen.y;
Circle(hdc, center_x, center_y, (int) tmp, rc, false, false);
HPEN prevPen = (HPEN)::SelectObject(hdc, hpTerrainLine);
for( int j = 1; j < 5 && tmp > 0; ++j) {
Circle(hdc, center_x, center_y, tmp -= NIBLSCALE(5), rc, true, true);
}
::SelectObject(hdc, prevPen);
break;
}
if (AATEnabled && !DoOptimizeRoute()) {
// ELSE HERE IS *** AAT ***
// JMW added iso lines
if ((i == ActiveWayPoint) || (mode.Is(Mode::MODE_TARGET_PAN) && (i == TargetPanIndex))) {
// JMW 20080616 flash arc line if very close to target
static bool flip = false;
if (DerivedDrawInfo.WaypointDistance < AATCloseDistance()*2.0) {
flip = !flip;
} else {
flip = true;
}
if (flip) {
for (int j = 0; j < MAXISOLINES - 1; j++) {
if (TaskStats[i].IsoLine_valid[j]
&& TaskStats[i].IsoLine_valid[j + 1]) {
_DrawLine(hdc, PS_SOLID, NIBLSCALE(2),
TaskStats[i].IsoLine_Screen[j],
TaskStats[i].IsoLine_Screen[j + 1],
RGB(0, 0, 255), rc);
}
}
}
}
}
}
}
if ((ActiveWayPoint < 2) && ValidTaskPoint(0) && ValidTaskPoint(1)) {
DrawStartEndSector(hdc, rc, Task[0].Start, Task[0].End, Task[0].Index, StartLine, StartRadius);
if (EnableMultipleStartPoints) {
for (i = 0; i < MAXSTARTPOINTS; i++) {
if (StartPoints[i].Active && ValidWayPoint(StartPoints[i].Index)) {
DrawStartEndSector(hdc, rc, StartPoints[i].Start, StartPoints[i].End,
StartPoints[i].Index, StartLine, StartRadius);
}
}
}
}
for (i = 0; ValidTaskPoint(i + 1); i++) {
int imin = min(Task[i].Index, Task[i + 1].Index);
int imax = max(Task[i].Index, Task[i + 1].Index);
// JMW AAT!
double bearing = Task[i].OutBound;
POINT sct1, sct2;
if (AATEnabled) {
LatLon2Screen(Task[i].AATTargetLon,
Task[i].AATTargetLat,
sct1);
LatLon2Screen(Task[i + 1].AATTargetLon,
Task[i + 1].AATTargetLat,
sct2);
DistanceBearing(Task[i].AATTargetLat,
Task[i].AATTargetLon,
Task[i + 1].AATTargetLat,
Task[i + 1].AATTargetLon,
NULL, &bearing);
// draw nominal track line
DrawDashLine(hdc, NIBLSCALE(1), // 091217
WayPointList[imin].Screen,
WayPointList[imax].Screen,
taskcolor, rc);
} else {
sct1 = WayPointList[imin].Screen;
sct2 = WayPointList[imax].Screen;
}
if ((i >= ActiveWayPoint && DoOptimizeRoute()) || !DoOptimizeRoute()) {
POINT ClipPt1 = sct1, ClipPt2 = sct2;
if(LKGeom::ClipLine((POINT) {rc.left, rc.top}, (POINT) {rc.right, rc.bottom}, ClipPt1, ClipPt2)) {
DrawMulticolorDashLine(hdc, size_tasklines,
sct1,
sct2,
taskcolor, RGB_BLACK,rc);
// draw small arrow along task direction
POINT p_p;
POINT Arrow[2] = {
{6, 6},
{-6, 6}
};
ScreenClosestPoint(sct1, sct2,
Orig_Aircraft, &p_p, NIBLSCALE(25));
threadsafePolygonRotateShift(Arrow, 2, p_p.x, p_p.y, bearing - DisplayAngle);
_DrawLine(hdc, PS_SOLID, size_tasklines-NIBLSCALE(1), Arrow[0], p_p, taskcolor, rc);
_DrawLine(hdc, PS_SOLID, size_tasklines-NIBLSCALE(1), Arrow[1], p_p, taskcolor, rc);
}
}
}
// Draw DashLine From current position to Active TurnPoint center
if(ValidTaskPoint(ActiveWayPoint)) {
POINT ptStart;
LatLon2Screen(DrawInfo.Longitude, DrawInfo.Latitude, ptStart);
DrawDashLine(hdc, NIBLSCALE(1),
ptStart,
WayPointList[Task[ActiveWayPoint].Index].Screen,
taskcolor, rc);
}
{
UnlockTaskData();
}
// restore original color
SetTextColor(hDCTemp, origcolor);
SelectObject(hdc, oldpen);
SelectObject(hdc, oldbrush);
}
void LKSurface::DrawDashPoly(const int width, const LKColor& color, const RasterPoint *pt, const unsigned npoints, const RECT& rc) {
for (unsigned Segment = 1; Segment < npoints; Segment++) {
DrawDashLine(width, pt[Segment - 1], pt[Segment], color, rc);
}
}
void MapWindow::DrawTask(HDC hdc, RECT rc, const POINT &Orig_Aircraft) {
int i;
double tmp;
COLORREF whitecolor = RGB_WHITE;
COLORREF origcolor = SetTextColor(hDCTemp, whitecolor);
HPEN oldpen = 0;
HBRUSH oldbrush = 0;
static short size_tasklines=0;
if (DoInit[MDI_DRAWTASK]) {
switch (ScreenSize) {
case ss480x272:
case ss272x480:
case ss320x240:
case ss240x320:
size_tasklines=NIBLSCALE(4);
break;
default:
size_tasklines=NIBLSCALE(3);
break;
}
DoInit[MDI_DRAWTASK]=false;
}
if (!WayPointList) return;
oldpen = (HPEN) SelectObject(hdc, hpStartFinishThick);
oldbrush = (HBRUSH) SelectObject(hdc, GetStockObject(HOLLOW_BRUSH));
LockTaskData(); // protect from external task changes
for (i = 1; ValidTaskPoint(i); i++) {
if (!ValidTaskPoint(i + 1)) { // final waypoint
if (ActiveWayPoint > 1 || !ValidTaskPoint(2)) {
// only draw finish line when past the first
// waypoint. FIXED 110307: or if task is with only 2 tps
DrawStartEndSector(hdc, rc, Task[i].Start, Task[i].End, Task[i].Index, FinishLine, FinishRadius);
}
} else { // normal sector
if (AATEnabled != TRUE) {
//_DrawLine(hdc, PS_DASH, NIBLSCALE(3), WayPointList[Task[i].Index].Screen, Task[i].Start, RGB_PETROL, rc);
//_DrawLine(hdc, PS_DASH, NIBLSCALE(3), WayPointList[Task[i].Index].Screen, Task[i].End, RGB_PETROL, rc);
DrawDashLine(hdc, size_tasklines, WayPointList[Task[i].Index].Screen, Task[i].Start, RGB_PETROL, rc);
DrawDashLine(hdc, size_tasklines, WayPointList[Task[i].Index].Screen, Task[i].End, RGB_PETROL, rc);
}
int Type = SectorType;
double Radius = SectorRadius;
if (AATEnabled) {
Type = Task[i].AATType;
Radius = Task[i].AATCircleRadius;
}
switch (Type) {
case CIRCLE:
tmp = Radius * zoom.ResScaleOverDistanceModify();
Circle(hdc,
WayPointList[Task[i].Index].Screen.x,
WayPointList[Task[i].Index].Screen.y,
(int) tmp, rc, false, false);
break;
case SECTOR:
tmp = Radius * zoom.ResScaleOverDistanceModify();
Segment(hdc,
WayPointList[Task[i].Index].Screen.x,
WayPointList[Task[i].Index].Screen.y, (int) tmp, rc,
Task[i].AATStartRadial - DisplayAngle,
Task[i].AATFinishRadial - DisplayAngle);
break;
case 2:
if (!AATEnabled) { // this Type exist only if not AAT task
// JMW added german rules
tmp = 500 * zoom.ResScaleOverDistanceModify();
Circle(hdc,
WayPointList[Task[i].Index].Screen.x,
WayPointList[Task[i].Index].Screen.y,
(int) tmp, rc, false, false);
tmp = 10e3 * zoom.ResScaleOverDistanceModify();
Segment(hdc,
WayPointList[Task[i].Index].Screen.x,
WayPointList[Task[i].Index].Screen.y, (int) tmp, rc,
Task[i].AATStartRadial - DisplayAngle,
Task[i].AATFinishRadial - DisplayAngle);
}
break;
}
if (AATEnabled && !DoOptimizeRoute()) {
// ELSE HERE IS *** AAT ***
// JMW added iso lines
if ((i == ActiveWayPoint) || (mode.Is(Mode::MODE_TARGET_PAN) && (i == TargetPanIndex))) {
// JMW 20080616 flash arc line if very close to target
static bool flip = false;
if (DerivedDrawInfo.WaypointDistance < AATCloseDistance()*2.0) {
flip = !flip;
} else {
flip = true;
}
if (flip) {
for (int j = 0; j < MAXISOLINES - 1; j++) {
if (TaskStats[i].IsoLine_valid[j]
&& TaskStats[i].IsoLine_valid[j + 1]) {
_DrawLine(hdc, PS_SOLID, NIBLSCALE(2),
TaskStats[i].IsoLine_Screen[j],
TaskStats[i].IsoLine_Screen[j + 1],
RGB(0, 0, 255), rc);
}
}
}
}
}
}
}
if ((ActiveWayPoint < 2) && ValidTaskPoint(0) && ValidTaskPoint(1)) {
DrawStartEndSector(hdc, rc, Task[0].Start, Task[0].End, Task[0].Index, StartLine, StartRadius);
if (EnableMultipleStartPoints) {
for (i = 0; i < MAXSTARTPOINTS; i++) {
if (StartPoints[i].Active && ValidWayPoint(StartPoints[i].Index)) {
DrawStartEndSector(hdc, rc, StartPoints[i].Start, StartPoints[i].End,
StartPoints[i].Index, StartLine, StartRadius);
}
}
}
}
for (i = 0; ValidTaskPoint(i + 1); i++) {
bool is_first = (Task[i].Index < Task[i + 1].Index);
int imin = min(Task[i].Index, Task[i + 1].Index);
int imax = max(Task[i].Index, Task[i + 1].Index);
// JMW AAT!
double bearing = Task[i].OutBound;
POINT sct1, sct2;
if (AATEnabled) {
LatLon2Screen(Task[i].AATTargetLon,
Task[i].AATTargetLat,
sct1);
LatLon2Screen(Task[i + 1].AATTargetLon,
Task[i + 1].AATTargetLat,
sct2);
DistanceBearing(Task[i].AATTargetLat,
Task[i].AATTargetLon,
Task[i + 1].AATTargetLat,
Task[i + 1].AATTargetLon,
NULL, &bearing);
// draw nominal track line
DrawDashLine(hdc, NIBLSCALE(1), // 091217
WayPointList[imin].Screen,
WayPointList[imax].Screen,
taskcolor, rc);
} else {
sct1 = WayPointList[Task[i].Index].Screen;
sct2 = WayPointList[Task[i + 1].Index].Screen;
}
if ((i >= ActiveWayPoint && DoOptimizeRoute()) || !DoOptimizeRoute()) {
if (is_first) {
DrawMulticolorDashLine(hdc, size_tasklines,
sct1,
sct2,
taskcolor, RGB_BLACK,rc);
} else {
DrawMulticolorDashLine(hdc, size_tasklines,
sct2,
sct1,
taskcolor, RGB_BLACK,rc);
}
// draw small arrow along task direction
POINT p_p;
POINT Arrow[2] = {
{6, 6},
{-6, 6}
};
ScreenClosestPoint(sct1, sct2,
Orig_Aircraft, &p_p, NIBLSCALE(25));
PolygonRotateShift(Arrow, 2, p_p.x, p_p.y,
bearing - DisplayAngle);
_DrawLine(hdc, PS_SOLID, size_tasklines-NIBLSCALE(1), Arrow[0], p_p, taskcolor, rc);
_DrawLine(hdc, PS_SOLID, size_tasklines-NIBLSCALE(1), Arrow[1], p_p, taskcolor, rc);
}
}
{
UnlockTaskData();
}
// restore original color
SetTextColor(hDCTemp, origcolor);
SelectObject(hdc, oldpen);
SelectObject(hdc, oldbrush);
}
void MapWindow::DrawProjectedTrack(HDC hdc, const RECT rc, const POINT Orig) {
if ((ActiveWayPoint<=0) || !ValidTaskPoint(ActiveWayPoint) || !AATEnabled) {
return;
}
if (DerivedDrawInfo.Circling) {
// don't display in various modes
return;
}
// TODO feature: maybe have this work even if no task?
// TODO feature: draw this also when in target pan mode
LockTaskData(); // protect from external task changes
double startLat = DrawInfo.Latitude;
double startLon = DrawInfo.Longitude;
double previousLat;
double previousLon;
if (AATEnabled) {
previousLat = Task[max(0,ActiveWayPoint-1)].AATTargetLat;
previousLon = Task[max(0,ActiveWayPoint-1)].AATTargetLon;
} else {
previousLat = WayPointList[Task[max(0,ActiveWayPoint-1)].Index].Latitude;
previousLon = WayPointList[Task[max(0,ActiveWayPoint-1)].Index].Longitude;
}
UnlockTaskData();
double distance_from_previous, bearing;
DistanceBearing(previousLat, previousLon,
startLat, startLon,
&distance_from_previous,
&bearing);
if (distance_from_previous < 100.0) {
bearing = DrawInfo.TrackBearing;
// too short to have valid data
}
POINT pt[2] = {{0,-75},{0,-400}};
if (mode.Is(Mode::MODE_TARGET_PAN)) {
double screen_range = GetApproxScreenRange();
double flow = 0.4;
double fhigh = 1.5;
screen_range = max(screen_range, DerivedDrawInfo.WaypointDistance);
double p1Lat;
double p1Lon;
double p2Lat;
double p2Lon;
FindLatitudeLongitude(startLat, startLon,
bearing, flow*screen_range,
&p1Lat, &p1Lon);
FindLatitudeLongitude(startLat, startLon,
bearing, fhigh*screen_range,
&p2Lat, &p2Lon);
LatLon2Screen(p1Lon, p1Lat, pt[0]);
LatLon2Screen(p2Lon, p2Lat, pt[1]);
} else if (fabs(bearing-DerivedDrawInfo.WaypointBearing)<10) {
// too small an error to bother
return;
} else {
pt[1].y = (long)(-max(MapRect.right-MapRect.left,
MapRect.bottom-MapRect.top)*1.2);
PolygonRotateShift(pt, 2, Orig.x, Orig.y,
bearing-DisplayAngle);
}
DrawDashLine(hdc, 2, pt[0], pt[1], RGB(0,0,0), rc);
}
int MapWindow::SharedTopView(HDC hdc, DiagrammStruct* psDia , double fAS_Bearing, double fWP_Bearing)
{
int iOldDisplayOrientation = DisplayOrientation;
DiagrammStruct m_Dia = *psDia;
RECT rct = m_Dia.rc;
unsigned short getsideviewpage=GetSideviewPage();
LKASSERT(getsideviewpage<NUMBER_OF_SHARED_MULTIMAPS);
LKASSERT(Current_Multimap_SizeY!=SIZE0);
DisplayOrientation = GetMMNorthUp(getsideviewpage);
switch(GetMMNorthUp(getsideviewpage))
{
case TRACKUP:
break;
case NORTHUP:
default:
m_Dia.fXMin = -m_Dia.fXMax;
break;
}
double fOldScale = zoom.Scale();
HFONT hfOld = (HFONT)SelectObject(hdc, LK8PanelUnitFont);
if(zoom.AutoZoom())
zoom.AutoZoom(false);
double fFact = 1.25 ;
#ifdef INIT_CASE
switch(ScreenSize) {
case ss896x672: fFact=0.938; break;
case ss800x480: fFact=0.750; break;
case ss640x480: fFact=0.938; break;
case ss480x272: fFact=0.708; break;
case ss400x240: fFact=0.750; break;
case ss320x240: fFact=0.938; break;
case ss480x800: fFact=1.250; break;
case ss480x640: fFact=1.250; break;
case ss272x480: fFact=1.250; break;
case ss240x400: fFact=1.250; break;
case ss240x320: fFact=1.250; break;
default: fFact=1.000; break;
}
#endif
if((ScreenSizeX > 0) && (ScreenSizeY > 0))
{
if(ScreenSizeX > ScreenSizeY)
fFact = (double)ScreenSizeY/(double)ScreenSizeX * 1.250;
}
PanLatitude = DrawInfo.Latitude;
PanLongitude = DrawInfo.Longitude;
switch(GetMMNorthUp(getsideviewpage))
{
case TRACKUP:
DisplayAngle = AngleLimit360(fAS_Bearing +270.0);
DisplayAircraftAngle = AngleLimit360(fWP_Bearing);
break;
case NORTHUP:
default:
DisplayAngle = 0;
if( getsideviewpage == IM_HEADING || getsideviewpage==IM_VISUALGLIDE)
DisplayAircraftAngle = AngleLimit360(fAS_Bearing);
else
DisplayAircraftAngle = AngleLimit360(DrawInfo.TrackBearing);
break;
}
int iOldLocator = EnableThermalLocator;
EnableThermalLocator =0;
MapWindow::ChangeDrawRect(rct); // set new area for terrain and topology
zoom.ModifyMapScale();
zoom.RequestedScale((m_Dia.fXMax -m_Dia.fXMin) * fFact * (DISTANCEMODIFY)/10.0f);
POINT Orig = { CalcDistanceCoordinat(0.0, (DiagrammStruct*) &m_Dia),(rct.bottom-rct.top)/2};
POINT Orig_Aircraft= {0,0};
zoom.ModifyMapScale();
zoom.UpdateMapScale();
CalculateScreenPositions( Orig, rct, &Orig_Aircraft);
CalculateScreenPositionsAirspace(rct);
//
// Expose variables in use for topview drawing
//
Current_Multimap_TopOrig=Orig_Aircraft;
Current_Multimap_TopZoom=GetInvDrawScale();
Current_Multimap_TopAngle=DisplayAngle;
bool terrainpainted=false;
if (IsMultimapTerrain() && DerivedDrawInfo.TerrainValid && RasterTerrain::isTerrainLoaded() ) {
LKTextBlack=false;
BlackScreen=false;
LockTerrainDataGraphics();
DrawTerrain(hdc, rct, GetAzimuth(), 40.0);
UnlockTerrainDataGraphics();
terrainpainted=true;
} else {
// We fill up the background wity chosen empty map color
// display border and fill background..
SelectObject(hdc, hInvBackgroundBrush[BgMapColor]);
SelectObject(hdc, GetStockObject(WHITE_PEN));
Rectangle(hdc,rct.left,rct.top,rct.right,rct.bottom);
// We force LK painting black values on screen depending on the background color in use
// blackscreen would force everything to be painted white, instead
LKTextBlack=BgMapColorTextBlack[BgMapColor];
if (BgMapColor>6 ) BlackScreen=true; else BlackScreen=false;
}
ResetLabelDeclutter();
// We reduce screen cluttering for some cases..
short olddecluttermode=DeclutterMode;
if (Current_Multimap_SizeY==SIZE4) goto _nomoredeclutter;
if (Current_Multimap_SizeY<SIZE3) {
DeclutterMode+=2;
} else {
if (Current_Multimap_SizeY==SIZE3)
DeclutterMode++;
}
if (DeclutterMode>dmVeryHigh) DeclutterMode=dmVeryHigh;
_nomoredeclutter:
if (IsMultimapTopology()) {
// Do not print topology labels, to be used with another config later!
// SaturateLabelDeclutter();
RECT rc_red = rct;
rc_red.bottom -= 3;
DrawTopology (hdc, rc_red);
} else {
// No topology is desired, but terrain requires water areas nevertheless
if (terrainpainted) {
RECT rc_red = rct;
rc_red.bottom -= 3;
DrawTopology (hdc, rc_red,true); // water only!
}
}
if (IsMultimapAirspace()) {
if ( (GetAirSpaceFillType() == asp_fill_ablend_full) || (GetAirSpaceFillType() == asp_fill_ablend_borders) ) {
DrawTptAirSpace(hdc, rct);
} else {
if ( GetAirSpaceFillType() == asp_fill_border_only)
DrawAirSpaceBorders(hdc, rct); // full screen, to hide clipping effect on low border
else
DrawAirSpace(hdc, rct); // full screen, to hide clipping effect on low border
}
// DrawAirspaceLabels( hdc, rct, Orig_Aircraft);
}
if (Flags_DrawTask && MapSpaceMode!=MSM_MAPASP && ValidTaskPoint(ActiveWayPoint) && ValidTaskPoint(1)) {
DrawTaskAAT(hdc, DrawRect);
DrawTask(hdc, DrawRect, Current_Multimap_TopOrig);
}
if (IsMultimapWaypoints()) {
DrawWaypointsNew(hdc,DrawRect);
}
if (Flags_DrawFAI)
DrawFAIOptimizer(hdc, DrawRect, Current_Multimap_TopOrig);
DeclutterMode=olddecluttermode; // set it back correctly
/* THIS STUFF DOES NOT WORK IN SHARED MAPS, YET
NEED FIXING LatLon2Screen for shared maps using Sideview
#ifdef GTL2
if (((FinalGlideTerrain == 2) || (FinalGlideTerrain == 4)) &&
DerivedDrawInfo.TerrainValid)
DrawTerrainAbove(hdc, DrawRect);
#endif
*/
//
// Stuff for MAPTRK only (M1)
if (MapSpaceMode==MSM_MAPTRK) {
if(IsMultimapTerrain() || IsMultimapTopology() ) {
if (FinalGlideTerrain && DerivedDrawInfo.TerrainValid)
DrawGlideThroughTerrain(hdc, DrawRect);
}
if (extGPSCONNECT)
DrawBearing(hdc, DrawRect);
// Wind arrow
if (IsMultimapOverlaysGauges())
DrawWindAtAircraft2(hdc, Current_Multimap_TopOrig, DrawRect);
}
if (MapSpaceMode==MSM_MAPWPT) {
if (extGPSCONNECT)
DrawBearing(hdc, DrawRect);
}
switch(GetMMNorthUp(getsideviewpage)) {
case NORTHUP:
default:
DrawCompass( hdc, rct, 0);
break;
case TRACKUP:
if(getsideviewpage == IM_HEADING || getsideviewpage == IM_VISUALGLIDE)
DrawCompass( hdc, rct, DrawInfo.TrackBearing-90.0);
else
DrawCompass( hdc, rct, DisplayAngle);
break;
}
/****************************************************************************************************
* draw vertical line
****************************************************************************************************/
POINT line[2];
line[0].x = rct.left;
line[0].y = Orig_Aircraft.y-1;
line[1].x = rct.right;
line[1].y = line[0].y;
switch(GetMMNorthUp(getsideviewpage))
{
case TRACKUP:
// Are we are not topview fullscreen?
if (Current_Multimap_SizeY<SIZE4 && !MapSpaceMode==MSM_VISUALGLIDE) {
DrawDashLine(hdc,NIBLSCALE(1), line[0], line[1], Sideview_TextColor, rct);
} else {
if (TrackBar) DrawHeadUpLine(hdc, Orig, rct, psDia->fXMin ,psDia->fXMax);
}
break;
case NORTHUP:
default:
if (TrackBar) {
DrawHeadUpLine(hdc, Orig, rct, psDia->fXMin ,psDia->fXMax);
}
break;
}
DrawAircraft(hdc, Orig_Aircraft);
// M3 has sideview always on, so wont apply here, and no need to check
if (Current_Multimap_SizeY==SIZE4) {
DrawMapScale(hdc,rct,0);
}
MapWindow::zoom.RequestedScale(fOldScale);
EnableThermalLocator = iOldLocator;
DisplayOrientation = iOldDisplayOrientation;
SelectObject(hdc, hfOld);
return 0;
}