void ComPort::StatusMessage(MsgType_t type, const TCHAR *caption, const TCHAR *fmt, ...) {
TCHAR tmp[127];
va_list ap;
LKASSERT(fmt!=NULL);
va_start(ap, fmt);
#ifdef TESTBENCH
int n = _vsntprintf(tmp, 127, fmt, ap);
#else
_vsntprintf(tmp, 127, fmt, ap);
#endif
va_end(ap);
#ifdef TESTBENCH
LKASSERT(n>=0); // Message to long for "tmp" buffer
#endif
tmp[126] = _T('\0');
if (caption) {
MessageBoxX(tmp, LKGetText(caption), type);
} else {
DoStatusMessage(tmp);
}
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/// Checks minimum and maximum waypoint count limits.
///
/// @param decl task declaration data
/// @param minCount minimum WP count
/// @param maxCount maximum WP count
/// @param errBufSize error message buffer size
/// @param errBuf[] [out] error message
///
/// @retval true WP count is in limits
/// @retval false WP count is outside limits (description in @p errBuf)
///
//static
bool DevBase::CheckWPCount(const Declaration_t& decl,
int minCount, int maxCount, unsigned errBufSize, TCHAR errBuf[])
{
// Must have at least two, max 12 waypoints
if (decl.num_waypoints < minCount)
{
#if BUGSTOP
LKASSERT(errBuf!=NULL);
#endif
if (errBuf==NULL) return(false);
// LKTOKEN _@M1412_ = "Not enough waypoints!"
_sntprintf(errBuf, errBufSize, _T("%s"), gettext(_T("_@M1412_")));
return(false);
}
if (decl.num_waypoints > maxCount)
{
#if BUGSTOP
LKASSERT(errBuf!=NULL);
#endif
if (errBuf==NULL) return(false);
// LKTOKEN _@M1413_ = "Too many waypoints!"
_sntprintf(errBuf, errBufSize, _T("%s"), gettext(_T("_@M1413_")));
return(false);
}
return(true);
} // CheckWPCount()
bool dlgAirspaceShowModal(bool coloredit){
colormode = coloredit;
ItemIndex = -1;
wf = dlgLoadFromXML(CallBackTable,
ScreenLandscape ? TEXT("dlgAirspace_L.xml") : TEXT("dlgAirspace_P.xml"),
ScreenLandscape ? IDR_XML_AIRSPACE_L : IDR_XML_AIRSPACE_P);
if (!wf) return false;
wAirspaceList = (WndListFrame*)wf->FindByName(TEXT("frmAirspaceList"));
LKASSERT(wAirspaceList!=NULL);
wAirspaceList->SetBorderKind(BORDERLEFT);
wAirspaceList->SetEnterCallback(OnAirspaceListEnter);
wAirspaceListEntry = (WndOwnerDrawFrame*)wf->
FindByName(TEXT("frmAirspaceListEntry"));
LKASSERT(wAirspaceListEntry!=NULL);
wAirspaceListEntry->SetCanFocus(true);
UpdateList();
changed = false;
wf->ShowModal();
delete wf;
wf = NULL;
return changed;
}
void CSTScreenBuffer::Create(int nWidth, int nHeight)
{
LKASSERT(nWidth>0);
LKASSERT(nHeight>0);
CreateBitmap(nWidth, nHeight);
}
void CuSondeLevel::updateTemps(double rh, double t)
// calculate dew point
// input: humi [%RH]
// temp [degreesC]
// output: dew point [degreesC]
{
double logEx, adewpoint;
LKASSERT((237.3+t)!=0);
logEx=0.66077+7.5*t/(237.3+t)+(log10(rh)-2);
LKASSERT((0.66077+7.5-logEx)!=0);
adewpoint = (logEx - 0.66077)*237.3/(0.66077+7.5-logEx);
// update statistics
if (0) {
nmeasurements++;
dewpoint = (adewpoint+dewpoint*(nmeasurements-1))/nmeasurements;
airTemp = (t+airTemp*(nmeasurements-1))/nmeasurements;
} else {
if (nmeasurements==0) {
dewpoint = adewpoint;
airTemp = t;
} else {
dewpoint = adewpoint*0.5+dewpoint*0.5;
airTemp = t*0.5+airTemp*0.5;
}
nmeasurements++;
}
}
bool dlgAirspaceShowModal(bool coloredit){
colormode = coloredit;
ItemIndex = -1;
if (!ScreenLandscape) {
TCHAR filename[MAX_PATH];
LocalPathS(filename, TEXT("dlgAirspace_L.xml"));
wf = dlgLoadFromXML(CallBackTable,
filename,
hWndMainWindow,
TEXT("IDR_XML_AIRSPACE_L"));
} else {
TCHAR filename[MAX_PATH];
LocalPathS(filename, TEXT("dlgAirspace.xml"));
wf = dlgLoadFromXML(CallBackTable,
filename,
hWndMainWindow,
TEXT("IDR_XML_AIRSPACE"));
}
if (!wf) return false;
wAirspaceList = (WndListFrame*)wf->FindByName(TEXT("frmAirspaceList"));
LKASSERT(wAirspaceList!=NULL);
wAirspaceList->SetBorderKind(BORDERLEFT);
wAirspaceList->SetEnterCallback(OnAirspaceListEnter);
wAirspaceListEntry = (WndOwnerDrawFrame*)wf->
FindByName(TEXT("frmAirspaceListEntry"));
LKASSERT(wAirspaceListEntry!=NULL);
wAirspaceListEntry->SetCanFocus(true);
// ScrollbarWidth is initialised from DrawScrollBar in WindowControls, so it might not be ready here
if ( wAirspaceList->ScrollbarWidth == -1) {
#if defined (PNA)
#define SHRINKSBFACTOR 1.0 // shrink width factor. Range .1 to 1 where 1 is very "fat"
#else
#define SHRINKSBFACTOR 0.75 // shrink width factor. Range .1 to 1 where 1 is very "fat"
#endif
wAirspaceList->ScrollbarWidth = (int) (SCROLLBARWIDTH_INITIAL * ScreenDScale * SHRINKSBFACTOR);
}
wAirspaceListEntry->SetWidth(wAirspaceList->GetWidth() - wAirspaceList->ScrollbarWidth - 5);
UpdateList();
changed = false;
wf->ShowModal();
delete wf;
wf = NULL;
return changed;
}
bool PGCicrcleTaskPt::CrossPoint(const ProjPt& prev, const ProjPt& next, ProjPt& optimized) {
ProjPt A = prev - m_Center;
ProjPt B = next - m_Center;
ProjPt A2(A.m_X * A.m_X, A.m_Y * A.m_Y);
ProjPt B2(B.m_X * B.m_X, B.m_Y * B.m_Y);
double R2 = (m_Radius * m_Radius);
bool PrevOutside = (A2.m_X + A2.m_Y) > R2;
bool NextOutside = (B2.m_X + B2.m_Y) > R2;
if (!PrevOutside && !NextOutside) {
return false; // no cross point
}
ProjPt AB = B - A;
double a = (AB.m_X * AB.m_X) + (AB.m_Y * AB.m_Y);
double b = 2 * ((AB.m_X * A.m_X) + (AB.m_Y * A.m_Y));
double c = A2.m_X + A2.m_Y - R2;
double bb4ac = (b * b) -(4 * a * c);
if (bb4ac < 0.0) {
return false;
}
bool bCrossPoint = false;
double k = 0.0;
if (bb4ac == 0.0) {
LKASSERT(a);
// one point
k = -b / (2 * a);
bCrossPoint = true;
}
if (bb4ac > 0.0) {
// Two point,
if ((PrevOutside && m_bExit) || (!PrevOutside && NextOutside)) {
LKASSERT(a);
k = (-b + sqrt(bb4ac)) / (2 * a); // ouput : prev ouside && Exit TP || prev inside && next outside
bCrossPoint = true;
} else {
LKASSERT(a);
k = (-b - sqrt(bb4ac)) / (2 * a); // input : prev outside && Enter TP
bCrossPoint = true;
}
}
if (bCrossPoint) {
ProjPt O = prev + ((next - prev) * k);
if (dot_product((next - prev), O - prev) > 0.0 &&
dot_product((prev - next), O - next) > 0.0) {
optimized = O;
return true;
}
}
// no point
return false;
}
//
// Change resolution of terrain,topology,airspace
//
bool MapWindow::ChangeDrawRect(const RECT rectarea)
{
LKASSERT(rectarea.right>0);
LKASSERT(rectarea.bottom>0);
// Passing an invalid area will be checked also later, and managed.
DrawRect=rectarea;
return true;
}
LKPaintSurface::LKPaintSurface(HWND hWnd) : LKSurface(), _hWnd(hWnd) {
LKASSERT(hWnd);
LKASSERT(::IsWindow(hWnd));
if (!Attach(::BeginPaint(hWnd, &_ps))) {
LKASSERT(false);
}
}
LKWindowSurface::LKWindowSurface(HWND hWnd) : LKSurface(), _hWnd() {
LKASSERT(hWnd);
LKASSERT(::IsWindow(hWnd));
if(!Attach(::GetDC(hWnd))) {
LKASSERT(false);
}
}
ListElement* dlgMultiSelectListShowModal(void) {
ItemIndex = -1;
if (iNO_ELEMENTS == 0) {
return NULL;
}
wf = dlgLoadFromXML(CallBackTable, ScreenLandscape ? IDR_XML_MULTISELECTLIST_L : IDR_XML_MULTISELECTLIST_P);
if (!wf) return NULL;
wf->SetTimerNotify(1000, OnTimer);
wMultiSelectListList = (WndListFrame*) wf->FindByName(TEXT("frmMultiSelectListList"));
LKASSERT(wMultiSelectListList != NULL);
wMultiSelectListList->SetBorderKind(BORDERLEFT);
wMultiSelectListList->SetEnterCallback(OnMultiSelectListListEnter);
wMultiSelectListListEntry = (WndOwnerDrawFrame*) wf->FindByName(TEXT("frmMultiSelectListListEntry"));
if(wMultiSelectListListEntry) {
/*
* control height must contains 2 text Line
* Check and update Height if necessary
*/
LKWindowSurface windowSurface(MainWindow);
LKBitmapSurface tmpSurface(windowSurface, 1, 1);
const auto oldFont = tmpSurface.SelectObject(wMultiSelectListListEntry->GetFont());
const int minHeight = 2 * tmpSurface.GetTextHeight(_T("dp")) + 2 * DLGSCALE(2);
tmpSurface.SelectObject(oldFont);
const int wHeight = wMultiSelectListListEntry->GetHeight();
if(minHeight > wHeight) {
wMultiSelectListListEntry->SetHeight(minHeight);
}
wMultiSelectListListEntry->SetCanFocus(true);
} else LKASSERT(0);
UpdateList();
wf->ShowModal();
delete wf;
wf = NULL;
iNO_ELEMENTS = 0;
NoAirfields = 0;
NoOutlands = 0;
NoWaypoints = 0;
NoAirspace = 0;
NoTaskPoints = 0;
return pResult;
}
bool LKSurface::Attach(HDC hDC) {
LKASSERT(NULL == _OutputDC); // only attach once.
LKASSERT(NULL == _AttribDC);
if (NULL == hDC) {
return false;
}
_OutputDC = hDC;
return true;
}
void LKWindowSurface::Create(Window& Wnd){
#ifdef WIN32
HWND hWnd = Wnd.Handle();
LKASSERT(hWnd);
LKASSERT(::IsWindow(hWnd));
if(!Attach(::GetDC(hWnd))) {
LKASSERT(false);
}
#else
_pCanvas = new WindowCanvas(Wnd);
#endif
}
void dlgHelpShowModal(const TCHAR* Caption, const TCHAR* HelpText) {
if (!Caption || !HelpText) {
return;
}
InitHelp();
wf = dlgLoadFromXML(CallBackTable,
ScreenLandscape ? TEXT("dlgHelp_L.xml") : TEXT("dlgHelp_P.xml"),
ScreenLandscape ? IDR_XML_HELP_L : IDR_XML_HELP_P);
LKASSERT(wf);
if (!wf) goto _getout;
TCHAR fullcaption[100];
_stprintf(fullcaption,TEXT("%s: %s"), gettext(TEXT("_@M336_")), Caption); // Help
wf->SetCaption(fullcaption);
wHelp = (WndListFrame*)wf->FindByName(TEXT("frmDetails"));
wHelpEntry = (WndOwnerDrawFrame *)NULL;
DrawListIndex=0;
LKASSERT(wHelp!=NULL);
if (!wHelp) goto _getout;
wHelp->SetBorderKind(BORDERLEFT);
wHelpEntry = (WndOwnerDrawFrame*)wf->FindByName(TEXT("frmDetailsEntry"));
LKASSERT(wHelpEntry);
if (!wHelpEntry) goto _getout;
wHelpEntry->SetCanFocus(true);
{
LKWindowSurface Surface(*wHelpEntry);
Surface.SelectObject(wHelpEntry->GetFont());
aTextLine.update(Surface, wHelpEntry->GetWidth(), LKgethelptext(HelpText));
}
wHelp->ResetList();
wHelp->Redraw();
wf->ShowModal();
delete wf;
aTextLine.clear();
_getout:
wf = NULL;
}
void addChecklist(TCHAR* name, TCHAR* details) {
if (nLists<MAXNOTES) {
ChecklistTitle[nLists] = (TCHAR*)malloc((_tcslen(name)+1)*sizeof(TCHAR));
ChecklistText[nLists] = (TCHAR*)malloc((_tcslen(details)+1)*sizeof(TCHAR));
LKASSERT(ChecklistTitle[nLists]!=NULL);
LKASSERT(ChecklistText[nLists]!=NULL);
_tcscpy(ChecklistTitle[nLists], name);
if (_tcslen(name)>=MAXNOTETITLE)
ChecklistTitle[nLists][MAXNOTETITLE-1]= 0;
_tcscpy(ChecklistText[nLists], details);
if (_tcslen(details)>=MAXNOTEDETAILS)
ChecklistText[nLists][MAXNOTEDETAILS-1]= 0;
nLists++;
}
}
/*****************************************************************************
* this function set the station name and frequency on the KRT2
*
* ComPort index of the comport the KRT2 is attached
* Active_Passive Active or passive station switch
* fFrequency station frequency
* Station station Name string
*
*****************************************************************************/
int SetKRT2Station(TCHAR *Command ,int Active_Passive, double fFrequency, TCHAR* Station)
{
TCHAR cActivePassive = 'U';
unsigned int len = 8;
unsigned int i;
int MHz= (int) fFrequency;
int kHz= (int) (fFrequency *1000.0 - MHz *1000 + 0.5);
int Chan = kHz/5;
//char Command[MAX_ANSWER_LEN];
char Airfield[10]={" --- "};
LKASSERT(Station !=NULL)
LKASSERT(Command !=NULL)
if(Command == NULL )
return false;
if(Station != NULL)
{
if( len > _tcslen(Station))
len =_tcslen(Station);
for (i= 0; i < len ; i++) {
Airfield[i] = Station[i];
}
}
switch (Active_Passive)
{
case ACTIVE_STATION:
cActivePassive = 'U';
break;
default:
case PASSIVE_STATION:
cActivePassive = 'R';
break;
}
_stprintf(Command, _T("%c%c%c%c%c%c%c%c%c%c%c%c%c"),STX,cActivePassive, (unsigned char)MHz, (unsigned char)Chan,
Airfield[0],
Airfield[1],
Airfield[2],
Airfield[3],
Airfield[4],
Airfield[5],
Airfield[6],
Airfield[7],
(unsigned char)MHz ^ (unsigned char)Chan );
// SendDataBufferISR(ComPort, Command, 13);
// sprintf(szLastCommandSend, Command); lastComPort = ComPort; // remember for 2nd try in case it fails
return 13;
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/// Show declaration progress dialog.
///
/// @param dlgType message type to be shown
///
//static
void DevBase::ShowProgress(DeclDlg dlgType)
{
const TCHAR* msgId;
switch (dlgType)
{
case decl_enable:
// LKTOKEN _@M1401_ = "Enabling declaration mode"
msgId = _T("_@M1401_"); break;
case decl_disable:
// LKTOKEN _@M1402_ = "Disabling declaration mode"
msgId = _T("_@M1402_"); break;
case decl_send:
// LKTOKEN _@M1403_ = "Sending declaration"
msgId = _T("_@M1403_"); break;
default:
#if BUGSTOP
LKASSERT(0);
#endif
msgId = _T("_@M1402_"); break;
return;
}
TCHAR buffer[max_dlg_msg_sz];
_sntprintf(buffer, max_dlg_msg_sz, _T("%s..."), gettext(msgId));
CreateProgressDialog(buffer);
} // ShowProgress()
void InitSineTable(void)
{
int i;
double angle;
double cosa, sina;
for(i=0;i<4096; i++)
{
angle = DEG_TO_RAD*((double)i*360)/4096;
cosa = cos(angle);
sina = sin(angle);
SINETABLE[i] = sina;
COSTABLE[i] = cosa;
ISINETABLE[i] = iround(sina*1024);
ICOSTABLE[i] = iround(cosa*1024);
if ((cosa>0) && (cosa<1.0e-8)) {
cosa = 1.0e-8;
}
if ((cosa<0) && (cosa>-1.0e-8)) {
cosa = -1.0e-8;
}
LKASSERT(cosa!=0);
INVCOSINETABLE[i] = 1.0/cosa;
}
}
int _MulDiv(int nNumber, int nNumerator, int nDenominator) {
long long res = nNumber;
res *= nNumerator;
LKASSERT(nDenominator!=0);
res /= nDenominator;
return res;
}
inline double GlidePolar::_SinkRateFast(const double &MC, const int &v) {
#if BUGSTOP
LKASSERT(v>=0 && v<=MAXSPEED); // sized maxspeed+1 in fact
#endif
if (v>MAXSPEED || v<=0 ) return sinkratecache[MAXSPEED]-MC; // UNMANAGED REALLY
return sinkratecache[v]-MC;
}
BOOL CSTScreenBuffer::Draw(HDC* pDC, POINT ptDest)
{
LKASSERT(m_hBitmap);
ReleaseDC();
POINT Origin = {0,0};
BOOL bResult = FALSE;
if (!memDc) {
memDc = CreateCompatibleDC(*pDC);
}
if (!memDc) {
return FALSE;
}
HBITMAP m_hOldBitmap = (HBITMAP)::SelectObject(memDc, m_hBitmap);
bResult = BitBlt(*pDC, ptDest.x, ptDest.y,
m_nWidth, m_nHeight,
memDc,
Origin.x, Origin.y, SRCCOPY);
::SelectObject(memDc, m_hOldBitmap);
// DeleteDC(memDc); memDc = NULL;
return bResult;
}
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);
}
}
}
int SearchStation(double Freq)
{
int i;
TCHAR szFreq[8] ;
_stprintf(szFreq, _T("%7.3f"),Freq);
double minDist =9999999;
int minIdx=0;
// LKASSERT(numvalidwp<=NumberOfWayPoints);
double fDist, fBear;
for (i=0; i<(int)WayPointList.size(); i++)
{
LKASSERT(ValidWayPointFast(i));
// LKASSERT(numvalidwp<=NumberOfWayPoints);
if (WayPointList[i].Latitude!=RESWP_INVALIDNUMBER)
{
DistanceBearing(GPS_INFO.Latitude,
GPS_INFO.Longitude,
WayPointList[i].Latitude,
WayPointList[i].Longitude,
&fDist,
&fBear);
if(fabs(Freq - StrToDouble(WayPointList[i].Freq,NULL)) < 0.001)
if(fDist < minDist)
{
minDist = fDist;
minIdx =i;
}
}
}
return minIdx;
}
//
// Overlays toggle order is:
// ALL ON, TEXT ONLY, GAUGES ONLY, ALL OFF
// We rotate through Gauges only if any of them are active!
//
void ToggleMultimapOverlays(void) {
short i=Get_Current_Multimap_Type();
LKASSERT( (i>=0) && (i<(MP_TOP+1)));
if (!HaveGaugesDrawn()) {
Multimap_Flags_Overlays_Text[i] = !Multimap_Flags_Overlays_Text[i];
return;
}
// ALLON-> TEXT ONLY
if ( Multimap_Flags_Overlays_Text[i] && Multimap_Flags_Overlays_Gauges[i] ) {
Multimap_Flags_Overlays_Gauges[i]=false;
return;
}
// TEXT->GAUGES
if ( Multimap_Flags_Overlays_Text[i] && !Multimap_Flags_Overlays_Gauges[i] ) {
Multimap_Flags_Overlays_Text[i]=false;
Multimap_Flags_Overlays_Gauges[i]=true;
return;
}
// GAUGES->ALLOFF
if ( !Multimap_Flags_Overlays_Text[i] && Multimap_Flags_Overlays_Gauges[i] ) {
Multimap_Flags_Overlays_Text[i]=false;
Multimap_Flags_Overlays_Gauges[i]=false;
return;
}
// ALLOFF->ALLON
Multimap_Flags_Overlays_Text[i]=true;
Multimap_Flags_Overlays_Gauges[i]=true;
}
void MapWindow::SetPanTaskEdit(unsigned TskPoint) {
LockTaskData();
if (ValidTaskPointFast(TskPoint)) {
MapWindow::Event_Pan(1);
PanTaskEdit = TskPoint;
PanLongitude = WayPointList[Task[PanTaskEdit].Index].Longitude;
PanLatitude = WayPointList[Task[PanTaskEdit].Index].Latitude;
if ((mode.Is(Mode::MODE_PAN)) || (mode.Is(Mode::MODE_TARGET_PAN))) {
{
if (Task[PanTaskEdit].Index != RESWP_PANPOS) {
RealActiveWaypoint = Task[PanTaskEdit].Index;
LKASSERT(ValidWayPoint(Task[PanTaskEdit].Index));
WayPointList[RESWP_PANPOS].Latitude =
WayPointList[RealActiveWaypoint].Latitude;
WayPointList[RESWP_PANPOS].Longitude =
WayPointList[RealActiveWaypoint].Longitude;
WayPointList[RESWP_PANPOS].Altitude =
WayPointList[RealActiveWaypoint].Altitude;
Task[PanTaskEdit].Index = RESWP_PANPOS;
RefreshMap();
}
}
}
}
UnlockTaskData();
}
//
// Back conversion from mapspace to maptype
//
short Get_Current_Multimap_Type() {
short ret=MP_MOVING;
if (!IsMultiMap()) return MP_MOVING;
switch(MapSpaceMode) {
case MSM_MAPRADAR:
ret=MP_RADAR;
break;
case MSM_MAPTRK:
ret=MP_MAPTRK;
break;
case MSM_MAPWPT:
ret=MP_MAPWPT;
break;
case MSM_MAPASP:
ret=MP_MAPASP;
break;
case MSM_MAPTEST:
ret=MP_TEST;
break;
case MSM_VISUALGLIDE:
ret=MP_VISUALGLIDE;
break;
default:
ret=MP_MOVING;
break;
}
LKASSERT(ret<=(MP_TOP+1));
return ret;
}
static void OnPaintWaypointPicto(WindowControl * Sender, HDC hDC){
#ifdef PICTORIALS
(void)Sender;
WndFrame *wPicto = ((WndFrame *)wf->FindByName(TEXT("frmWaypointPicto")));
LKASSERT(wPicto!=NULL);
RECT *prc;
prc = wPicto->GetBoundRect();
// StartupStore(_T("..Entered OnPaintWaypointPicto \n"));
SetBkColor (hDC, RGB_LIGHTGREY);
if (WayPointCalc[SelectedWaypoint].IsLandable )
{
MapWindow::DrawRunway(hDC,&WayPointList[SelectedWaypoint], *prc, 3500*ScreenScale, true);
}
else
{
MapWindow::DrawWaypointPictoBg(hDC, *prc);
MapWindow::DrawWaypointPicto(hDC, *prc, &WayPointList[SelectedWaypoint]);
}
#endif
}
void FlarmIdFile::GetAsString(FILE* hFile, int charCount, TCHAR *res)
{
LKASSERT((charCount * 2)<=100);
unsigned bytesToRead = std::min(charCount * 2, 100);
char bytes[100];
fread(bytes, 1, bytesToRead, (FILE*)hFile);
TCHAR *curChar = res;
for (unsigned z = 0; z < bytesToRead && (z+1) < array_size(bytes) ; z += 2)
{
char tmp[3];
tmp[0] = bytes[z];
tmp[1] = bytes[z+1];
tmp[2] = 0;
int i;
sscanf(tmp, "%2x", &i);
*curChar = (unsigned char)i;
curChar ++;
}
*curChar = 0;
}
// It is called GPSVario but it is really a vario using best altitude available.. baro if possible
void Vario(NMEA_INFO *Basic, DERIVED_INFO *Calculated)
{
static double LastTime = 0;
static double LastAlt = 0;
double myTime;
myTime=Basic->Time;
if(myTime <= LastTime) {
LastTime = myTime;
LastAlt = Calculated->NavAltitude;
} else {
double Gain = Calculated->NavAltitude - LastAlt;
double dT = (Basic->Time - LastTime);
LKASSERT(dT!=0);
if (dT==0) dT=1;
Calculated->GPSVario = Gain / dT;
LastAlt = Calculated->NavAltitude;
LastTime = myTime;
}
if (!Basic->VarioAvailable || ReplayLogger::IsEnabled()) {
Calculated->Vario = Calculated->GPSVario;
} else {
// get value from instrument
Calculated->Vario = Basic->Vario;
}
}
void MapWindow::Zoom::ModifyMapScale()
{
// limit zoomed in so doesn't reach silly levels
if(_bMapScale)
*_requestedScale = LimitMapScale(*_requestedScale); // FIX VENTA remove limit
_scaleOverDistanceModify = *_requestedScale / DISTANCEMODIFY;
LKASSERT(_scaleOverDistanceModify!=0);
_resScaleOverDistanceModify = GetMapResolutionFactor() / _scaleOverDistanceModify;
_drawScale = _scaleOverDistanceModify;
_drawScale = _drawScale / 111194;
LKASSERT(_drawScale!=0);
_drawScale = GetMapResolutionFactor() / _drawScale;
_invDrawScale = 1.0 / _drawScale;
_scale = *_requestedScale;
_realscale = *_requestedScale/DISTANCEMODIFY/1000;
}
