Frame.cpp

Go to the documentation of this file.

/*
 *  Roadnav
 *  Frame.cpp   
 *
 *  Copyright (c) 2004 - 2008 Richard L. Lynch <rllynch@users.sourceforge.net>
 *
 *  This program is free software; you can redistribute it and/or
 *  modify it under the terms of version 2 of the GNU General Public License
 *  as published by the Free Software Foundation.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
//////////////////////////////////////////////////////////////////////////////
/// \file
///
/// Contains the frame class for the application, and the associated
/// event handlers.
///
//////////////////////////////////////////////////////////////////////////////

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

#ifdef _MSC_VER
#pragma warning(disable: 4786)
#pragma warning(disable: 4800)
#endif

#include <wx/wx.h>
#include <wx/minifram.h>
#include <wx/string.h>
#include <wx/print.h>
#include <wx/printdlg.h>
#include <wx/filename.h>
#include <wx/tokenzr.h>
#include <wx/choicdlg.h>

#if defined _WINDOWS
#include <windows.h> // for WM_TIMECHANGE
#endif

#ifdef HAVE_MATH_H
#include <math.h>
#endif

#include "libroadnav/Map.h"
#include "libroadnav/MapLookup.h"
#include "libroadnav/MapSupport.h"
#include "libroadnav/MapMath.h"
#include "libroadnav/MapRepresentations.h"
#include "libroadnav/Debug.h"
#include "Frame.h"
#include "MapEventExtender.h"
#include "GPSMonitorThread.h"
#include "LocationDialog.h"
#include "CountyDialog.h"
#include "libroadnav/MapCounty.h"
#include "libroadnav/MapState.h"
#include "Printout.h"
#include "SaveAsSettingsDialog.h"
#include "libroadnav/MapDataImporter_GNISDECI.h"
#include "libroadnav/MapDataImporter_TigerLine.h"
#include "TTSFactory.h"
#include "Support.h"
#include "KeyboardDialog.h"
#include "libroadnav/StringTable.h"

#include "OptionsLaunch.h"

#ifdef USE_OPENSTREETMAP
#include "libroadnav/MapDataImporter_OSM.h"
#endif

#include "libroadnav/MapDataImporter_GPX.h"

#include "libroadnav/MapZip.h"
#include "libroadnav/URLs.h"
#include "libroadnav/DownloadFiles.h"
#include "LCDprocInterface.h"

#include "appicon16.xpm"
#include "appicon32.xpm"
#include "appicon64.xpm"

#include <vector>

using namespace std;

//////////////////////////////////////////////////////////////////////////////
/// 
/// Menu item IDs
///
//////////////////////////////////////////////////////////////////////////////
enum
{
    idMapControl = 0,
    idWhatsNearBy,

#ifdef USE_SCRIPTING    
    idFileRunScript,
#endif
    idFileSaveAs,
    idFilePrint,
    idFilePrintPreview,
    
    idViewCompass,
    idViewAerialPhotos,
    idView3DMode,
    idViewScale,
    idViewGPSHistory,
    idViewZoomIn,
    idViewZoomOut,
    idViewZoomMax,
    idViewZoomMin,
    idViewGPSMarker,
    idViewGPSWindow,
    idViewWhatsNearByWindow,
    idViewFullScreen,
    
    idMapSetAddress,
    idMapWaypoints,
    idMapSetAngle,
    idMapGetDirections,
    idMapGetDirectionsAccel,
    idMapMoveCenterLeft,
    idMapMoveCenterRight,
    idMapMoveCenterUp,
    idMapMoveCenterDown,

    idToolsMeasure,
    idToolsZoom,

    idToolsDownloadMaps,
#ifdef USE_OPENSTREETMAP
    idToolsDownloadOSMMaps,
    idToolsImportOSMMaps,
#endif

    idToolsImportGPXData,
    
    idSolarTimerTest,
    idRefreshMapControl,
    idEscape,

    idViewZoom0,
    idViewZoom1,
    idViewZoom2,
    idViewZoom3,
    idViewZoom4,
    idViewZoom5,
    idViewZoom6,
    idViewZoom7,
    idViewZoom8,
    idViewZoom9,
    idViewZoom10,
    idViewZoom11,
    idViewZoom12,
    idViewZoom13,
    idViewZoom14,
};

#define TIMER_INIT      4

#ifdef USE_SCRIPTING
#define TIMER_SCRIPTING 5
#endif

#define TIMER_CONFIGFLUSH   6

//////////////////////////////////////////////////////////////////////////////
///
/// MapFrame event table
///
//////////////////////////////////////////////////////////////////////////////
BEGIN_EVENT_TABLE(MapFrame, wxFrame)
#ifdef USE_SCRIPTING    
    EVT_MENU  (idFileRunScript, MapFrame::OnFileRunScript)
#endif
    EVT_MENU  (idFileSaveAs, MapFrame::OnFileSaveAs)
    EVT_BUTTON(idFileSaveAs, MapFrame::OnFileSaveAs)
    EVT_MENU  (idFilePrint, MapFrame::OnFilePrint)
    EVT_BUTTON(idFilePrint, MapFrame::OnFilePrint)
    EVT_MENU  (idFilePrintPreview, MapFrame::OnFilePrintPreview)
    EVT_MENU  (wxID_EXIT, MapFrame::OnFileExit)
    EVT_BUTTON(wxID_EXIT, MapFrame::OnFileExit)

    EVT_MENU  (idViewCompass, MapFrame::OnViewCompass)
    EVT_MENU  (idViewAerialPhotos, MapFrame::OnViewAerialPhotos)
    EVT_MENU  (idView3DMode, MapFrame::OnView3DMode)
    EVT_MENU  (idViewScale, MapFrame::OnViewScale)
    EVT_MENU  (idViewGPSHistory, MapFrame::OnViewGPSHistory)
    EVT_MENU  (idViewZoomIn, MapFrame::OnViewZoomIn)
    EVT_BUTTON(idViewZoomIn, MapFrame::OnViewZoomIn)
    EVT_MENU  (idViewZoomOut, MapFrame::OnViewZoomOut)
    EVT_BUTTON(idViewZoomOut, MapFrame::OnViewZoomOut)
    EVT_MENU  (idViewZoomMax, MapFrame::OnViewZoomMax)
    EVT_MENU  (idViewZoomMin, MapFrame::OnViewZoomMin)
    EVT_MENU  (idViewGPSMarker, MapFrame::OnViewGPSMarker)
    EVT_BUTTON(idViewGPSMarker, MapFrame::OnViewGPSMarkerToggle)
    EVT_MENU  (idViewGPSWindow, MapFrame::OnViewGPSWindow)
    EVT_MENU  (idViewWhatsNearByWindow, MapFrame::OnViewWhatsNearByWindow)
    EVT_MENU  (idViewFullScreen, MapFrame::OnViewFullScreen)

    EVT_MENU  (idMapSetAddress, MapFrame::OnMapSetAddress)
    EVT_BUTTON(idMapSetAddress, MapFrame::OnMapSetAddress)
    EVT_MENU  (idMapWaypoints, MapFrame::OnMapWaypoints)
    EVT_MENU  (idMapSetAngle, MapFrame::OnMapSetAngle)
    EVT_MENU  (idMapGetDirections, MapFrame::OnMapGetDirections)
    EVT_BUTTON(idMapGetDirections, MapFrame::OnMapGetDirectionsAccel)
    EVT_MENU  (idMapGetDirectionsAccel, MapFrame::OnMapGetDirectionsAccel)
    EVT_MENU  (idMapMoveCenterLeft, MapFrame::OnMapMoveCenterLeft)
    EVT_BUTTON(idMapMoveCenterLeft, MapFrame::OnMapMoveCenterLeft)
    EVT_MENU  (idMapMoveCenterRight, MapFrame::OnMapMoveCenterRight)
    EVT_BUTTON(idMapMoveCenterRight, MapFrame::OnMapMoveCenterRight)
    EVT_MENU  (idMapMoveCenterUp, MapFrame::OnMapMoveCenterUp)
    EVT_BUTTON(idMapMoveCenterUp, MapFrame::OnMapMoveCenterUp)
    EVT_MENU  (idMapMoveCenterDown, MapFrame::OnMapMoveCenterDown)
    EVT_BUTTON(idMapMoveCenterDown, MapFrame::OnMapMoveCenterDown)

    EVT_MENU  (idToolsMeasure, MapFrame::OnToolsMeasure)
    EVT_UPDATE_UI(idToolsMeasure, MapFrame::OnUpdateToolsMeasure)
    EVT_MENU  (idToolsZoom, MapFrame::OnToolsZoom)
    EVT_UPDATE_UI(idToolsZoom, MapFrame::OnUpdateToolsZoom)

    EVT_BUTTON(idToolsDownloadMaps, MapFrame::OnToolsDownloadTIGERLineMaps)
    EVT_MENU  (idToolsDownloadMaps, MapFrame::OnToolsDownloadTIGERLineMaps)

#ifdef USE_OPENSTREETMAP
    EVT_MENU  (idToolsDownloadOSMMaps, MapFrame::OnToolsDownloadOSMMaps)
    EVT_MENU  (idToolsImportOSMMaps, MapFrame::OnToolsImportOSMMaps)
#endif

    EVT_MENU  (idToolsImportGPXData, MapFrame::OnToolsImportGPXData)
    
    EVT_BUTTON(wxID_PREFERENCES, MapFrame::OnToolsPreferences)
    EVT_MENU  (wxID_PREFERENCES, MapFrame::OnToolsPreferences)

    EVT_MENU  (wxID_ABOUT, MapFrame::OnHelpAbout)

    EVT_MENU  (idSolarTimerTest, MapFrame::OnSolarTimerTest)
    EVT_MENU  (idRefreshMapControl, MapFrame::RedrawMap)

    EVT_MENU  (idEscape, MapFrame::OnEscapeKey)

    EVT_BUTTON(idWhatsNearBy, MapFrame::OnWhatsNearbyDoubleClick)

    EVT_BUTTON(idMapControl, MapFrame::OnMapRecentered)
    EVT_COMMAND_RIGHT_CLICK(idMapControl, MapFrame::OnDownloadCounty)

    EVT_SOLAR(MapFrame::OnSolarEvent)
    EVT_IDLE(MapFrame::OnIdle)

    EVT_SIZE(wxSkinnableFrame::OnSize)
    EVT_TIMER(TIMER_REFRESH, wxSkinnableFrame::OnTimerRefresh)
    
    EVT_TIMER(TIMER_INIT, MapFrame::OnTimerInit)

    EVT_TIMER(TIMER_CONFIGFLUSH, MapFrame::OnTimerConfigFlush)

#ifdef USE_SCRIPTING
    EVT_TIMER(TIMER_SCRIPTING, MapFrame::OnTimerScripting)
#endif

    EVT_GPS(MapFrame::OnGPSUpdate)
    
    EVT_CLOSE(MapFrame::OnClose)

    EVT_MENU  (idViewZoom0, MapFrame::OnViewZoomLevel)
    EVT_BUTTON(idViewZoom0, MapFrame::OnViewZoomLevel)
    EVT_MENU  (idViewZoom1, MapFrame::OnViewZoomLevel)
    EVT_BUTTON(idViewZoom1, MapFrame::OnViewZoomLevel)
    EVT_MENU  (idViewZoom2, MapFrame::OnViewZoomLevel)
    EVT_BUTTON(idViewZoom2, MapFrame::OnViewZoomLevel)
    EVT_MENU  (idViewZoom3, MapFrame::OnViewZoomLevel)
    EVT_BUTTON(idViewZoom3, MapFrame::OnViewZoomLevel)
    EVT_MENU  (idViewZoom4, MapFrame::OnViewZoomLevel)
    EVT_BUTTON(idViewZoom4, MapFrame::OnViewZoomLevel)
    EVT_MENU  (idViewZoom5, MapFrame::OnViewZoomLevel)
    EVT_BUTTON(idViewZoom5, MapFrame::OnViewZoomLevel)
    EVT_MENU  (idViewZoom6, MapFrame::OnViewZoomLevel)
    EVT_BUTTON(idViewZoom6, MapFrame::OnViewZoomLevel)
    EVT_MENU  (idViewZoom7, MapFrame::OnViewZoomLevel)
    EVT_BUTTON(idViewZoom7, MapFrame::OnViewZoomLevel)
    EVT_MENU  (idViewZoom8, MapFrame::OnViewZoomLevel)
    EVT_BUTTON(idViewZoom8, MapFrame::OnViewZoomLevel)
    EVT_MENU  (idViewZoom9, MapFrame::OnViewZoomLevel)
    EVT_BUTTON(idViewZoom9, MapFrame::OnViewZoomLevel)
    EVT_MENU  (idViewZoom10, MapFrame::OnViewZoomLevel)
    EVT_BUTTON(idViewZoom10, MapFrame::OnViewZoomLevel)
    EVT_MENU  (idViewZoom11, MapFrame::OnViewZoomLevel)
    EVT_BUTTON(idViewZoom11, MapFrame::OnViewZoomLevel)
    EVT_MENU  (idViewZoom12, MapFrame::OnViewZoomLevel)
    EVT_BUTTON(idViewZoom12, MapFrame::OnViewZoomLevel)
    EVT_MENU  (idViewZoom13, MapFrame::OnViewZoomLevel)
    EVT_BUTTON(idViewZoom13, MapFrame::OnViewZoomLevel)
    EVT_MENU  (idViewZoom14, MapFrame::OnViewZoomLevel)
    EVT_BUTTON(idViewZoom14, MapFrame::OnViewZoomLevel)
END_EVENT_TABLE()

//////////////////////////////////////////////////////////////////////////////
///
/// \brief MapFrame constructor - create controls and initialize them
///
//////////////////////////////////////////////////////////////////////////////
MapFrame::MapFrame(wxString title) : wxSkinnableFrame((wxFrame *) NULL, -1, title), m_tLastRoadTypeZoomingCheck((time_t) 0)
{
    wxConfigBase * pConfig = wxConfigBase::Get();

    //////////////////////////////////////////////////////////////////////////////
    // Icon
    //////////////////////////////////////////////////////////////////////////////

    wxIconBundle icbApp;

    wxIcon icoApp16;
    wxBitmap bmpAppIcon16(appicon16_xpm);
    icoApp16.CopyFromBitmap(bmpAppIcon16);
    icbApp.AddIcon(icoApp16);

    wxIcon icoApp32;
    wxBitmap bmpAppIcon32(appicon32_xpm);
    icoApp32.CopyFromBitmap(bmpAppIcon32);
    icbApp.AddIcon(icoApp32);

    wxIcon icoApp64;
    wxBitmap bmpAppIcon64(appicon64_xpm);
    icoApp64.CopyFromBitmap(bmpAppIcon64);
    icbApp.AddIcon(icoApp64);

    SetIcons(icbApp);

    //////////////////////////////////////////////////////////////////////////////
    // Initialize variables
    //////////////////////////////////////////////////////////////////////////////

    m_ptGPS.Set(0, 0);
    m_fGPSHeading = 0;
    m_fGPSSpeed = 0;
    m_bOnGPSInProgress = false;
    m_bNewGPSData = false;
    m_bGPSJustRun = false;
    m_iRoadTypeZoomingCountdown = -1;
    m_eRoadTypeZoomingCurrentType = RecordTypeDefault;
    m_eRoadTypeZoomingNextType = RecordTypeDefault;

    m_bScreenTracksGPS = pConfig->Read(wxT("TrackGPSMarker"), true);
    
    m_iSpeedControlledDetailLevelOffset = 0;

    m_ToolMode = toolNone;
    
    m_pcTTS = ConstructTTS(TTSTypeNone);

    m_pdData = NULL;

    InitializeThemes();

    //////////////////////////////////////////////////////////////////////////
    // Create the "What's Nearby" miniframe
    //////////////////////////////////////////////////////////////////////////

    m_pfrmWhatsNearBy = new WhatsNearByFrame(this, idWhatsNearBy, new MapData_Tiles());
    
    //////////////////////////////////////////////////////////////////////////////
    // Create controls
    //////////////////////////////////////////////////////////////////////////////
    m_ctlMap = new MapControl(&m_cRecords, &m_MapAppearanceSettings, this, idMapControl, wxDefaultPosition, wxDefaultSize);
    m_ctlMap->Hide();

    //////////////////////////////////////////////////////////////////////////////
    // Extend map control event handling
    //////////////////////////////////////////////////////////////////////////////
    m_ctlMap->PushEventHandler(new MapEventExtender(this, m_ctlMap));

    //////////////////////////////////////////////////////////////////////////////
    // Add map control to skin
    //////////////////////////////////////////////////////////////////////////////

    AddNamedControl(m_ctlMap, wxT("map"));

    m_pctlCompass = NULL;

    //////////////////////////////////////////////////////////////////////////////
    // File Menu
    //////////////////////////////////////////////////////////////////////////////

    wxMenu * menuFile = new wxMenu;
#ifdef USE_SCRIPTING
    menuFile->Append(idFileRunScript, wxT("Run S&cript..."));
#endif
    menuFile->Append(idFileSaveAs, wxT("Save &as...\tCtrl-s"));
    menuFile->Append(idFilePrint, wxT("&Print...\tCtrl-p"));
    menuFile->Append(idFilePrintPreview, wxT("P&rint Preview..."));
    menuFile->AppendSeparator();
    menuFile->Append(wxID_EXIT, wxT("E&xit"));

    //////////////////////////////////////////////////////////////////////////////
    // View Menu
    //////////////////////////////////////////////////////////////////////////////
    m_menuView = new wxMenu;
    
    m_menuView->AppendCheckItem(idViewCompass, wxT("&Compass"));
    m_menuView->Check(idViewCompass, TRUE);
    
    m_menuView->AppendCheckItem(idViewAerialPhotos, wxT("Aerial &Photos"));
    m_menuView->Check(idViewAerialPhotos, pConfig->Read(wxT("AerialPhotosVisible"), (long int) 0));
    
    m_menuView->AppendCheckItem(idView3DMode, wxT("&3D Mode"));
    m_menuView->Check(idView3DMode, pConfig->Read(wxT("3DMode"), (long int) 0));
    
    m_menuView->AppendCheckItem(idViewScale, wxT("&Scale"));
    m_menuView->Check(idViewScale, TRUE);

    m_menuView->AppendCheckItem(idViewGPSHistory, wxT("GPS &History"));
    m_menuView->Check(idViewGPSHistory, pConfig->Read(wxT("GPSHistory"), (long int) 1));

    m_menuView->AppendCheckItem(idViewGPSMarker, wxT("Map Tracks &GPS"));
    m_menuView->Check(idViewGPSMarker, m_bScreenTracksGPS);

    m_menuView->AppendCheckItem(idViewGPSWindow, wxT("G&PS Window"));
    m_menuView->Check(idViewGPSWindow, pConfig->Read(wxT("GPSWindowVisible"), (long int) 0));

    m_menuView->AppendCheckItem(idViewWhatsNearByWindow, wxT("What's Nearby Window"));
    m_menuView->Check(idViewWhatsNearByWindow, pConfig->Read(wxT("WhatsNearByWindowVisible"), (long int) 0));

    m_menuView->AppendSeparator();

    m_menuView->Append(idViewZoomIn, wxT("Zoom &In\t+"));
    m_menuView->Append(idViewZoomOut, wxT("Zoom &Out\t-"));

    m_menuView->Append(idViewZoomMax, wxT("Zoom Max"));
    m_menuView->Append(idViewZoomMin, wxT("Zoom Min"));

#if defined(__DARWIN__)
    m_menuView->AppendCheckItem(idViewFullScreen, wxT("&Full Screen\tCtrl-Shift-F"));
#else
    m_menuView->AppendCheckItem(idViewFullScreen, wxT("&Full Screen\tF11"));
#endif
    m_menuView->Check(idViewFullScreen, FALSE);

    //////////////////////////////////////////////////////////////////////////////
    // Map Menu
    //////////////////////////////////////////////////////////////////////////////
    m_menuMap = new wxMenu;
    m_menuMap->Append(idMapSetAddress, wxT("Set &Address...\tCtrl-A"));
    m_menuMap->Append(idMapWaypoints, wxT("&Waypoints..."));
    m_menuMap->Append(idMapSetAngle, wxT("Set Map Orientation..."));
    m_menuMap->AppendCheckItem(idMapGetDirections, wxT("Get &Directions...\tCtrl-D"));
    m_menuMap->Check(idMapGetDirections, (long int) 0);

    //////////////////////////////////////////////////////////////////////////////
    // Tools Menu
    //////////////////////////////////////////////////////////////////////////////
    wxMenu * menuTools = new wxMenu;

    menuTools->AppendCheckItem(idToolsMeasure, wxT("Measure"));
    menuTools->AppendCheckItem(idToolsZoom, wxT("Zoom"));

    menuTools->AppendSeparator();

    menuTools->Append(idToolsDownloadMaps, wxT("Download TIGER/Line &Maps (US)..."));
#ifdef USE_OPENSTREETMAP
    menuTools->Append(idToolsDownloadOSMMaps, wxT("Download &OpenStreetMap Maps (non-US)..."));
    menuTools->Append(idToolsImportOSMMaps, wxT("Import O&penStreetMap XML Maps (non-US)..."));
#endif
    menuTools->Append(idToolsImportGPXData, wxT("Import &GPX Data..."));
    menuTools->Append(wxID_PREFERENCES, wxT("&Preferences..."));

    //////////////////////////////////////////////////////////////////////////////
    // Help Menu
    //////////////////////////////////////////////////////////////////////////////
    wxMenu * menuHelp = new wxMenu;
    menuHelp->Append(wxID_ABOUT, wxT("&About..."));

    //////////////////////////////////////////////////////////////////////////////
    // Menu Bar
    //////////////////////////////////////////////////////////////////////////////
    wxMenuBar * mbMenu = new wxMenuBar(wxMB_DOCKABLE);
    mbMenu->Append(menuFile, wxT("&File"));
    mbMenu->Append(m_menuView, wxT("&View"));
    mbMenu->Append(m_menuMap, wxT("&Map"));
    mbMenu->Append(menuTools, wxT("&Tools"));
    mbMenu->Append(menuHelp, wxT("&Help"));

    SetMenuBar(mbMenu);

    //////////////////////////////////////////////////////////////////////////
    // Accelerators
    //////////////////////////////////////////////////////////////////////////

    wxAcceleratorEntry entries[15];
    entries[0].Set(wxACCEL_NORMAL,  (int) wxT('+'), idViewZoomIn);
    entries[1].Set(wxACCEL_NORMAL,  (int) wxT('='), idViewZoomIn);
    entries[2].Set(wxACCEL_SHIFT,   (int) wxT('='), idViewZoomIn);
    entries[3].Set(wxACCEL_NORMAL,  (int) wxT('-'), idViewZoomOut);
    entries[4].Set(wxACCEL_NORMAL,  WXK_UP,     idMapMoveCenterUp);
    entries[5].Set(wxACCEL_NORMAL,  WXK_DOWN,   idMapMoveCenterDown);
    entries[6].Set(wxACCEL_NORMAL,  WXK_LEFT,   idMapMoveCenterLeft);
    entries[7].Set(wxACCEL_NORMAL,  WXK_RIGHT,  idMapMoveCenterRight);
#if defined(__DARWIN__)
    entries[8].Set(wxACCEL_CTRL | wxACCEL_SHIFT,    (int) wxT('F'), idViewFullScreen);
#else
    entries[8].Set(wxACCEL_NORMAL,  WXK_F11,    idViewFullScreen);
#endif
    entries[9].Set(wxACCEL_CTRL,    (int) wxT('A'), idMapSetAddress);
    entries[10].Set(wxACCEL_CTRL,   (int) wxT('D'), idMapGetDirectionsAccel);
    entries[11].Set(wxACCEL_CTRL,   (int) wxT('S'), idFileSaveAs);
    entries[12].Set(wxACCEL_CTRL,   (int) wxT('P'), idFilePrint);
    entries[13].Set(wxACCEL_CTRL,   (int) wxT('T'), idSolarTimerTest);
    entries[14].Set(wxACCEL_NORMAL, WXK_ESCAPE, idEscape);

    wxAcceleratorTable accel(sizeof(entries)/sizeof(wxAcceleratorEntry), entries);
    SetAcceleratorTable(accel);
    
    //////////////////////////////////////////////////////////////////////////
    // Status Bar
    //////////////////////////////////////////////////////////////////////////
    CreateStatusBar(3);
    
    //////////////////////////////////////////////////////////////////////////
    // Create the GPS status miniframe
    //////////////////////////////////////////////////////////////////////////
    m_pfrmGPS = new GPSFrame(this);
    
    //////////////////////////////////////////////////////////////////////////
    // Create the directions miniframe
    //////////////////////////////////////////////////////////////////////////

    m_pfrmDirections = new DirectionsFrame(this);
    
    //////////////////////////////////////////////////////////////////////////////
    // Read config settings and apply them
    //////////////////////////////////////////////////////////////////////////////

    int iMarkerCount;
    int iMarker;
    
    m_ctlMap->ClearMarkers();
    pConfig->Read(wxT("MarkerCount"), &iMarkerCount, 0);
    for (iMarker = 0; iMarker < iMarkerCount; iMarker++)
    {
        wxString strMarker;
        MapMarker cMarker;

        pConfig->Read(wxString::Format(wxT("Marker%d"), iMarker), &strMarker, wxT(""));
        
        cMarker.FromString(strMarker);
        
        m_ctlMap->SetMarker(cMarker);
    }
    
    m_ctlMap->ClearMarker(wxT("GPS Position"));
    m_ctlMap->ClearMarker(wxT("Starting Address"));
    m_ctlMap->ClearMarker(wxT("Ending Address"));
    
    double fCenterLong;
    double fCenterLat;
    pConfig->Read(wxT("CenterLong"), &fCenterLong, -82);
    pConfig->Read(wxT("CenterLat"), &fCenterLat, 40);
    m_ctlMap->SetCenterCoordinates(Point(fCenterLong, fCenterLat));

    double fMapAngle;
    pConfig->Read(wxT("MapAngle"), &fMapAngle, 0);
    m_ctlMap->SetAngle(fMapAngle);

    int iDetailLevel;
    pConfig->Read(wxT("DetailLevel"), &iDetailLevel, 1);
    m_ctlMap->SetDetailLevel(iDetailLevel);
    
    for (iDetailLevel = 0; iDetailLevel <= LAST_RECORD_TYPE; iDetailLevel++)
        m_ariRoadTypeZoomingDetailLevels[iDetailLevel] = pConfig->Read(wxString::Format(wxT("RoadTypeZoomingDetailLevels%d"), iDetailLevel), -1);
    
    //////////////////////////////////////////////////////////////////////////////
    // Restore the previous size and position of this frame
    //////////////////////////////////////////////////////////////////////////////

    RestoreWindowPosition(this, wxT("Window"));

    //////////////////////////////////////////////////////////////////////////////
    // Restore the previous size and position of the GPS window
    //////////////////////////////////////////////////////////////////////////////

    RestoreWindowPosition(m_pfrmGPS, wxT("GPSWindow"));

    //////////////////////////////////////////////////////////////////////////////
    // Restore the previous size and position of the directions window
    //////////////////////////////////////////////////////////////////////////////

    RestoreWindowPosition(m_pfrmDirections, wxT("DirectionsWindow"));

    //////////////////////////////////////////////////////////////////////////////
    // Restore the previous size and position of the what's nearby window
    //////////////////////////////////////////////////////////////////////////////

    RestoreWindowPosition(m_pfrmWhatsNearBy, wxT("WhatsNearByWindow"));

    //////////////////////////////////////////////////////////////////////////////
    // Maximize if it was maximized before
    //////////////////////////////////////////////////////////////////////////////

    int iIsMaximized;
    pConfig->Read(wxT("IsMaximized"), &iIsMaximized, 1);
    if (iIsMaximized)
        Maximize();

    //////////////////////////////////////////////////////////////////////////////
    // Sync map control to menu state
    //////////////////////////////////////////////////////////////////////////////

    if (m_menuView->IsChecked(idViewGPSWindow))
        m_pfrmGPS->Show();
    else
        m_pfrmGPS->Hide();
    
    if (m_menuView->IsChecked(idViewWhatsNearByWindow))
        m_pfrmWhatsNearBy->Show();
    else
        m_pfrmWhatsNearBy->Hide();
    
    m_ctlMap->ShowCompass(m_menuView->IsChecked(idViewCompass));
    m_ctlMap->ShowScale(m_menuView->IsChecked(idViewScale));
    m_ctlMap->ShowAerialPhotos(m_menuView->IsChecked(idViewAerialPhotos), pConfig->Read(wxT("AutoDownloadMaps"), (int) 1));
    m_ctlMap->Enable3DMode(m_menuView->IsChecked(idView3DMode));

    //////////////////////////////////////////////////////////////////////////////
    // Initialize scripting
    //////////////////////////////////////////////////////////////////////////////
#ifdef USE_SCRIPTING
    m_pScripting = new Scripting(this, m_ctlMap);
    
    if (pConfig->Read(wxT("ScriptingStartupScriptEnabled"), (long) 0))
    {
        // run script
        m_pScripting->RunFromFile(pConfig->Read(wxT("ScriptingStartupScriptFilename"), wxT("")));
        
        // erase script if erase option enabled
        if (pConfig->Read(wxT("ScriptingStartupScriptErase"), (long) 0))
            wxRemoveFile(pConfig->Read(wxT("ScriptingStartupScriptFilename"), wxT("")));
    }
    
    m_ptmrScripting = new wxTimer(this, TIMER_SCRIPTING);
    m_ptmrScripting->Start(500, false);
#endif

    //////////////////////////////////////////////////////////////////////////////
    // Load up the theme definitions
    //////////////////////////////////////////////////////////////////////////////
    m_ThemeManager.Load(wxConfigBase::Get());

    //////////////////////////////////////////////////////////////////////////
    // Start up the helper threads
    //////////////////////////////////////////////////////////////////////////
    
    m_GPSMonitorThread = new GPSMonitorThread(this);
    m_GPSMonitorThread->Create();

    m_DownloadThread = new DownloadThread(this, idRefreshMapControl);
    m_DownloadThread->Create();
    m_DownloadThread->Run();
    
    m_ptmrInit = new wxTimer(this, TIMER_INIT);
    m_ptmrInit->Start(1, true);

    m_ptmrConfigFlush = new wxTimer(this, TIMER_CONFIGFLUSH);
    m_ptmrConfigFlush->Start(60 * 1000, false);

    m_bShowPopupGPSErrors = false;
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief Periodically flush all settings to disk.
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnTimerConfigFlush(wxTimerEvent& event)
{
    if (wxConfigBase::Get()->Read(wxT("MarkerCount"), (long) 0) != m_ctlMap->GetMarkerCount())
        SaveMarkers();

    wxConfigBase::Get()->Flush();
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief Initialization function called 1ms after MapFrame is created.
///
/// This function just calls MapInit after MapFrame has finished
/// initializing. It can't be called earlier due to some wxMSW sockets 
/// glitches that occasionally cause a hang in wxURL when wxURL is used
/// before a wxFrame is fully initialized.
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnTimerInit(wxTimerEvent& event)
{
    wxCommandEvent ev;
    
    if (MapInit())
    {
        Close(TRUE);
        return;
    }

    ApplyPreferences();
        
    LCDprocInit();

    OnMapRecentered(ev);

    m_GPSMonitorThread->Run();
}

#ifdef USE_SCRIPTING
//////////////////////////////////////////////////////////////////////////////
///
/// \brief 0.5 second timer function that pumps the scripting engine.
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnTimerScripting(wxTimerEvent& event)
{
    m_pScripting->Pump();
}
#endif

//////////////////////////////////////////////////////////////////////////////
///
/// \brief MapFrame destructor
///
//////////////////////////////////////////////////////////////////////////////
MapFrame::~MapFrame()
{
    m_ThemeManager.Save(wxConfigBase::Get());
    delete m_ptmrInit;
    delete m_ptmrConfigFlush;
    if (m_pdData != NULL)
        delete m_pdData;
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief Determine whether the mouse is in measure, zoom, or neither mode
///
//////////////////////////////////////////////////////////////////////////////
EToolMode MapFrame::GetToolMode() const
{
   return m_ToolMode;
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief Put the mouse into measure, zoom, or neither mode
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::SetToolMode(EToolMode mode)
{
   m_ToolMode = mode;
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief Provides access to the MapData object
///
//////////////////////////////////////////////////////////////////////////////
IMapData& MapFrame::GetMapData()
{
    return m_cRecords;
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief Provides access the MapAppearanceSettings object
///
//////////////////////////////////////////////////////////////////////////////
MapAppearanceSettings& MapFrame::GetMapAppearanceSettings()
{
    return m_MapAppearanceSettings;
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief Idle handler - update the status bar as necessary
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnIdle(wxIdleEvent & event)
{
    if (!IsShown())
        return;
        
    wxString strOldText;
    wxString strNewText;

    strOldText = GetStatusBar()->GetStatusText(2);

    strNewText = wxString::Format(wxT("Detail Level: %d"), m_ctlMap->GetDetailLevel());

    if (strOldText != strNewText)
        SetStatusText(strNewText, 2);

    
    {
        bool bNewGPSData = false;
        wxGPSEvent evGPS;
        
        if (m_bGPSJustRun)
        {
            m_mtxGPS.Lock();
            m_bNewGPSData = false;
            m_bGPSJustRun = false;
            m_mtxGPS.Unlock();
        }
        
        m_mtxGPS.Lock();
        bNewGPSData = m_bNewGPSData;
        evGPS = m_evGPS;
        m_mtxGPS.Unlock();
        
        if (bNewGPSData)
        {
            OnGPSUpdateIdle(evGPS);
            
            m_mtxGPS.Lock();
            m_bNewGPSData = false;
            m_bGPSJustRun = true;
            m_mtxGPS.Unlock();
            
            event.RequestMore();
        }
    }
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief EVT_SOLAR handler - handle transition to daytime/nighttime
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnSolarEvent(SolarEvent& event)
{
    UpdateTheme();
    m_ctlMap->MapUpdated(UPDATED_THEME);
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief Select the appropriate theme for the current time
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::UpdateTheme()
{
    bool bViewPhotos;
    wxConfigBase * pConfig = wxConfigBase::Get();

    pConfig->Read(wxT("AerialPhotosVisible"), &bViewPhotos, false);

    if ( bViewPhotos )
    {
        m_MapAppearanceSettings = m_ThemeManager.GetPhotoTheme();
    }
    else
    {
        switch( m_ThemeManager.GetThemeUsage() )
        {
            case ThemeManager::AutoSwap:
                m_SolarTimer.Start();
                if ( m_SolarTimer.IsDaytime() || !m_SolarTimer.Valid())
                    m_MapAppearanceSettings = m_ThemeManager.GetDayTheme();
                else
                    m_MapAppearanceSettings = m_ThemeManager.GetNightTheme();
                break;
            
            case ThemeManager::Night:
                m_SolarTimer.Stop();
                m_MapAppearanceSettings = m_ThemeManager.GetNightTheme();
                break;
            
            case ThemeManager::Day:
                m_SolarTimer.Stop();
                m_MapAppearanceSettings = m_ThemeManager.GetDayTheme();
                break;
        }
    }

    //////////////////////////////////////////////////////////////////////////////
    // Apply the skin
    //////////////////////////////////////////////////////////////////////////////
    wxString strSkinPath;

    if (m_SolarTimer.IsDaytime())
        pConfig->Read(wxT("SkinPath-Day"), &strSkinPath, wxT("Default-Day"));
    else
        pConfig->Read(wxT("SkinPath-Night"), &strSkinPath, wxT("Default-Night"));

    bool bSkinLoaded = false;

    if (strSkinPath != wxT(""))
        bSkinLoaded = !LoadSkin(strSkinPath, true);

    if (!bSkinLoaded)
    {
        LoadSkin(
wxT("<?xml version=\"1.0\">\
<roadnavskin>\
    <layout>\
        <control name=\"map\">\
            <region>\
                <topleft>\
                    <x/>\
                    <y/>\
                </topleft>\
                <bottomright>\
                    <x multiplier=\"1\"/>\
                    <y multiplier=\"1\"/>\
                </bottomright>\
            </region>\
        </control>\
    </layout>\
</roadnavskin>"),
            false);
    }

    m_pfrmGPS->SetFont(GetFont());
    m_pfrmGPS->SetBackgroundStyle(wxBG_STYLE_COLOUR);   
    m_pfrmGPS->SetBackgroundColour(m_MapAppearanceSettings.GetMiscColor(MiscColorBackground));
    m_pfrmGPS->SetForegroundColour(m_MapAppearanceSettings.GetMiscColor(MiscColorForeground));
    m_pfrmGPS->SafeRefresh();

    m_pfrmWhatsNearBy->SetFont(GetFont());
    m_pfrmWhatsNearBy->SetBackgroundStyle(wxBG_STYLE_COLOUR);   
    m_pfrmWhatsNearBy->SetBackgroundColour(m_MapAppearanceSettings.GetMiscColor(MiscColorBackground));
    m_pfrmWhatsNearBy->SetForegroundColour(m_MapAppearanceSettings.GetMiscColor(MiscColorForeground));
    
    m_pfrmDirections->SetFont(GetFont());
    m_pfrmDirections->SetBackgroundColour(m_MapAppearanceSettings.GetMiscColor(MiscColorBackground));
    m_pfrmDirections->SetForegroundColour(m_MapAppearanceSettings.GetMiscColor(MiscColorForeground));
    
    UpdateSkinState();
}

#if defined _WINDOWS

//////////////////////////////////////////////////////////////////////////////
///
/// \brief Catches the WM_TIMECHANGE Windows message
///
/// wxWidgets does not support the WM_TIMECHANGE event so we will add it
/// here in a non-portable way
///
//////////////////////////////////////////////////////////////////////////////
long MapFrame::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
{
   long result = wxFrame::MSWWindowProc(nMsg,wParam,lParam);
   if ( nMsg == WM_TIMECHANGE )
   {
      // user changed the clock in some way... notify the solar timer
      wxTimeChangeEvent event;
      m_SolarTimer.AddPendingEvent(event);
   }
   return result;
}

#endif

//////////////////////////////////////////////////////////////////////////////
///
/// \brief Called to process a wxGPSEvent object. This just saves the object
/// and lets it get processed in the idle handler.
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnGPSUpdate(const wxGPSEvent & evGPS)
{
    wxMutexLocker mlLocker(m_mtxGPS);
    
    m_evGPS = evGPS;
    m_bNewGPSData = true;
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief Handle speed controlled zooming
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnGPSUpdateIdleSpeedControlledZooming(const wxGPSEvent & evGPS)
{
    double fSpeed = evGPS.m_fSpeed;

    //////////////////////////////////////////////////////////////////////////////
    // Beginning of speed controlled zooming code
    //////////////////////////////////////////////////////////////////////////////
    int iDesiredSpeedControlledDetailLevelOffset;
    bool bSignificantOffset;
    double fHighestExceededCutoff;
    vector<double>::iterator iCutoff;
    double fHysteresis;
    
    fHysteresis = 5;
    iDesiredSpeedControlledDetailLevelOffset = 0;
    bSignificantOffset = false;
    fHighestExceededCutoff = -1000;

    // determine the correct offset due to the current velocity         
    for (iCutoff = m_vSpeedControlledDetailLevelCutoffs.begin(); iCutoff != m_vSpeedControlledDetailLevelCutoffs.end(); iCutoff++)
    {
        if (fSpeed > *iCutoff)
        {
            iDesiredSpeedControlledDetailLevelOffset--;
            
            if (*iCutoff > fHighestExceededCutoff)
                fHighestExceededCutoff = *iCutoff;
        }
    }
    
    if (fSpeed - fHighestExceededCutoff > fHysteresis)
        bSignificantOffset = true;
    
    // check for accelerating through auto-zoom cutoff + fHysteresis
    if ((m_iSpeedControlledDetailLevelOffset - iDesiredSpeedControlledDetailLevelOffset > 1) ||
        (m_iSpeedControlledDetailLevelOffset - iDesiredSpeedControlledDetailLevelOffset == 1 && bSignificantOffset))
    {
        m_iSpeedControlledDetailLevelOffset--;
        m_ctlMap->LessDetail();
    }
    
    // check for decelerating through auto-zoom cutoff
    if ((iDesiredSpeedControlledDetailLevelOffset - m_iSpeedControlledDetailLevelOffset >= 1))
    {
        m_iSpeedControlledDetailLevelOffset++;
        m_ctlMap->MoreDetail();
    }

    //////////////////////////////////////////////////////////////////////////////
    // End of speed controlled zooming code
    //////////////////////////////////////////////////////////////////////////////
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief Handle zooming based on road type
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnGPSUpdateIdleRoadTypeZooming(const wxGPSEvent & evGPS)
{
    if (m_adrGPS.m_eRecordType == m_eRoadTypeZoomingCurrentType || 
            m_adrGPS.m_eRecordType < FIRST_RECORD_TYPE_ROAD || 
            m_adrGPS.m_eRecordType > LAST_RECORD_TYPE_ROAD)
    {
        // road type has not changed
        // or the current road type isn't really a road
        m_iRoadTypeZoomingCountdown = -1;
        m_eRoadTypeZoomingNextType = m_adrGPS.m_eRecordType;
    }
    else if (m_adrGPS.m_eRecordType != m_eRoadTypeZoomingNextType)
    {
        // okay, we just observed the road type change
        m_iRoadTypeZoomingCountdown = 2; // add one, and multiply by frequency to determine responsive time
        m_eRoadTypeZoomingNextType = m_adrGPS.m_eRecordType;
    }
    else if (m_iRoadTypeZoomingCountdown > 0)
    {
        // we have observed the road type has changed for a little while now
        // getting ready to switch
        m_iRoadTypeZoomingCountdown--;
    }
    else
    {
        // alright, time to switch
        wxASSERT(m_iRoadTypeZoomingCountdown == 0);
        
        // remember current detail level for old type
        m_ariRoadTypeZoomingDetailLevels[m_eRoadTypeZoomingCurrentType] = m_ctlMap->GetDetailLevel() - m_iSpeedControlledDetailLevelOffset;
        
        // set type to new type
        m_eRoadTypeZoomingCurrentType = m_adrGPS.m_eRecordType;
        
        // set detail level to new type's detail level
        if (m_ariRoadTypeZoomingDetailLevels[m_eRoadTypeZoomingCurrentType] >= 0)
            m_ctlMap->SetDetailLevel(m_ariRoadTypeZoomingDetailLevels[m_eRoadTypeZoomingCurrentType] + m_iSpeedControlledDetailLevelOffset);
        
        m_iRoadTypeZoomingCountdown = -1;
    }
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief Repositions the center of the map so that the current GPS
/// coordinates are on the screen.
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnGPSUpdateIdleKeepGPSOnScreen(const wxGPSEvent & evGPS)
{
    double fScreenEdge = 0.1;
    double fSafety = 0.05;
    double fScreenRelativeHeading;

    wxPoint ptScreenGPS;
    wxSize szMapCtl;

    const Point & pt = evGPS.m_pt;
    double fHeading = evGPS.m_fHeading;

    wxRealPoint ptRelativeScreenGPS;
            
    ptScreenGPS = m_ctlMap->MapLongLatToScreen(pt);
    szMapCtl = m_ctlMap->GetSize();
    
    fScreenRelativeHeading = fHeading - m_ctlMap->GetAngle();
    
    ptRelativeScreenGPS.x = (((double) ptScreenGPS.x) / szMapCtl.x);
    ptRelativeScreenGPS.y = (((double) ptScreenGPS.y) / szMapCtl.y);

    if (!m_ctlMap->IsOnScreen(pt))
    {
        // yikes, we're really far off
        m_ctlMap->SetCenterCoordinates(pt);
    }
    else if (ptRelativeScreenGPS.x < fScreenEdge)
    {
        // we're close to the left edge .. slide the screen left
        m_ctlMap->MoveCenterLeft(1.0 - ptRelativeScreenGPS.x - fScreenEdge - fSafety);
        
        // move it up/down so the car passes through the center of the screen
        m_ctlMap->MoveCenterUp(0.5 - ptRelativeScreenGPS.y - (0.5 - fScreenEdge - fSafety) * sin_deg(fScreenRelativeHeading - 90));
    }
    else if (ptRelativeScreenGPS.y < fScreenEdge)
    {
        // we're close to the top edge .. slide the screen up
        m_ctlMap->MoveCenterUp(1.0 - ptRelativeScreenGPS.y - fScreenEdge - fSafety);
        
        // move it left/right so the car passes through the center of the screen
        m_ctlMap->MoveCenterLeft(0.5 - ptRelativeScreenGPS.x - (0.5 - fScreenEdge - fSafety) * cos_deg(fScreenRelativeHeading - 90));
    }
    else if (ptRelativeScreenGPS.x > (1.0 - fScreenEdge))
    {
        // we're close to the right edge .. slide the screen right
        m_ctlMap->MoveCenterRight(ptRelativeScreenGPS.x - fScreenEdge - fSafety);
        
        // move it up/down so the car passes through the center of the screen
        m_ctlMap->MoveCenterUp(0.5 - ptRelativeScreenGPS.y - (0.5 - fScreenEdge - fSafety) * sin_deg(fScreenRelativeHeading - 90));
    }
    else if (ptRelativeScreenGPS.y > (1.0 - fScreenEdge))
    {
        // we're close to the bottom edge .. slide the screen down
        m_ctlMap->MoveCenterDown(ptRelativeScreenGPS.y - fScreenEdge - fSafety);
        
        // move it left/right so the car passes through the center of the screen
        m_ctlMap->MoveCenterLeft(0.5 - ptRelativeScreenGPS.x - (0.5 - fScreenEdge - fSafety) * cos_deg(fScreenRelativeHeading - 90));
    }
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief Adjust the angle of the map so the heading is pointing up.
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnGPSUpdateIdlePointGPSHeadingUp(const wxGPSEvent & evGPS)
{
    double fDesiredAngle;
    double fHeading = evGPS.m_fHeading;
    double fAngleDifference;
    
    fDesiredAngle = floor((fHeading + 22.5) / 45) * 45;
    
    fAngleDifference = fabs(m_ctlMap->GetAngle() - fHeading);

    if (fAngleDifference > 180)
        fAngleDifference = 360 - fAngleDifference;

    if (fAngleDifference > 45)
        m_ctlMap->SetAngle(fDesiredAngle);
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief Appends the current GPS coordinates to the GPS history track.
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnGPSUpdateIdleUpdateGPSTrack(const wxGPSEvent & evGPS)
{
    MapTrack * pTrack;
    const Point & pt = evGPS.m_pt;

    pTrack = m_ctlMap->GetTrack(wxT("GPSHistory"));

    if (!pTrack)
    {
        vector<Point> vptCoords;

        vptCoords.push_back(pt);

        MapTrack cTrack(wxT("GPSHistory"), vptCoords, wxColour(0, 255, 255), false);

        m_ctlMap->SetTrack(cTrack);

        pTrack = m_ctlMap->GetTrack(wxT("GPSHistory"));
    }

    pTrack->m_vptCoordinates.push_back(pt);

    m_ctlMap->SetTrack(*pTrack);
}

//////////////////////////////////////////////////////////////////////////////
/// 
/// \brief Called when new GPS coordinates have been received.
///
/// Moves the marker to indicate where the GPS says we are
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnGPSUpdateIdle(const wxGPSEvent & evGPS)
{
    LibRoadnavDebug0(wxT("GPS"), wxT("MapFrame::OnGPSUpdate"));

    if (m_bOnGPSInProgress)
    {
        LibRoadnavDebug0(wxT("GPS"), wxT("MapFrame::OnGPSUpdate already running - exiting"));
        return;
    }
        
    m_bOnGPSInProgress = true;
    
    LibRoadnavDebug5(wxT("GPS"), wxT("bEnabled = %d, bActive = %d, bLocked = %d, fSpeed = %.1f, fHeading = %.1f"),
                                evGPS.m_bEnabled,
                                evGPS.m_bActive,
                                evGPS.m_bLocked,
                                evGPS.m_fSpeed,
                                evGPS.m_fHeading);

    if ((m_bShowPopupGPSErrors || evGPS.m_bFatalError) && !evGPS.m_strErrorMessage.IsEmpty())
    {
        // be annoying with fatal errors only
        wxMessageBox(evGPS.m_strErrorMessage, wxT("Error"), wxOK | wxICON_ERROR, this);
    }

    wxConfigBase * pConfig = wxConfigBase::Get();

    if (evGPS.m_bLocked)
    {
        double fHeadingChange = fabs(m_fGPSHeading - evGPS.m_fHeading);
        bool bPositionChange;
        bool bAngleChange;
        

        bPositionChange = fabs(m_ptGPS.GetLong() - evGPS.m_pt.GetLong()) > 2e-6 || fabs(m_ptGPS.GetLat() - evGPS.m_pt.GetLat()) > 2e-6;
        
        if (fHeadingChange > 180)
            fHeadingChange = 360 - fHeadingChange;
        
        bAngleChange = fHeadingChange > 5;

        if (bPositionChange || bAngleChange)
        {
            bool bDoRoadTypeZoomingNow = false;
            bool bKeepGPSCentered = pConfig->Read(wxT("KeepGPSCentered"), (long) true);

            if (bPositionChange)
            {
                Address adrGPS;

                if (pConfig->Read(wxT("RoadTypeZooming"), (long) false))
                {
                    if (wxDateTime::Now() - m_tLastRoadTypeZoomingCheck > wxTimeSpan(0, 0, 2, 0))
                    {
                        bDoRoadTypeZoomingNow = true;
                        m_tLastRoadTypeZoomingCheck = wxDateTime::Now();

                        m_cRecords.LoadRegion(evGPS.m_pt, evGPS.m_pt, OnlyRoadsVisibility(), false);
                    }
                }

                adrGPS = FindCoordinates(evGPS.m_pt, OnlyRoadsVisibility(), false, false, &m_cRecords);

                if (adrGPS.m_bValid)
                    m_adrGPS = adrGPS;
                else
                    m_adrGPS.m_ptCoordinates = evGPS.m_pt;
            }

            m_ctlMap->SetMarker(    MapMarker(  wxT("GPS Position"), 
                                                &m_adrGPS, 
                                                evGPS.m_fHeading, 
                                                pConfig->Read(wxT("GPS Callout Box"), (long) false), 
                                                pConfig->Read(wxT("GPS Small Label"), true), 
                                                pConfig->Read(wxT("GPS Arrow"), true),
                                                pConfig->Read(wxT("GPS Icon"), wxT("")),
                                                false
                                                ),
                                    false);
            
            OnGPSUpdateIdleSpeedControlledZooming(evGPS);

            if (bDoRoadTypeZoomingNow)
                OnGPSUpdateIdleRoadTypeZooming(evGPS);
            
            if (m_bScreenTracksGPS && !bKeepGPSCentered)
                OnGPSUpdateIdleKeepGPSOnScreen(evGPS);
            
            if (m_menuView->IsChecked(idView3DMode))
            {
                m_ctlMap->SetCenterCoordinates(evGPS.m_pt);
                m_ctlMap->SetAngle(evGPS.m_fHeading);
            }
            else
            {
                if (!m_bNorthAlwaysUp)
                    OnGPSUpdateIdlePointGPSHeadingUp(evGPS);
                    
                if (m_bScreenTracksGPS && bKeepGPSCentered)
                    m_ctlMap->SetCenterCoordinates(evGPS.m_pt);
            }

            if (m_menuView->IsChecked(idViewGPSHistory))
                OnGPSUpdateIdleUpdateGPSTrack(evGPS);

            m_SolarTimer.SetPosition(evGPS.m_pt.GetLong(),evGPS.m_pt.GetLat());

            m_ptGPS = evGPS.m_pt;
            m_fGPSSpeed = evGPS.m_fSpeed;
            m_fGPSHeading = evGPS.m_fHeading;
        }
    }

    if (m_pctlCompass)
        m_pctlCompass->SetDirection(evGPS.m_fHeading);

    wxString strStreet =    
                wxString::Format(wxT("%d "), m_adrGPS.m_iStreetNumber) + 
                m_adrGPS.m_strStreetName + 
                wxT(" ") + 
                m_adrGPS.m_strStreetType;
                
    SetVariable(wxT("GPS Street"), strStreet);
    SetVariable(wxT("GPS City"), m_adrGPS.m_strCityName);
    SetVariable(wxT("GPS State"), m_adrGPS.m_strStateName);
    
    // if the home zip code is not set, then set it from the GPS coordinates
    if (m_adrGPS.m_iZipCode)
    {
        int iZipHome;
        pConfig->Read(wxT("HomeZipCode"), &iZipHome, 0);
        
        if (!iZipHome)
        {
            pConfig->Write(wxT("HomeZipCode"), m_adrGPS.m_iZipCode);
            wxConfigBase::Get()->Flush();
        }
    }

    if (!evGPS.m_strErrorMessage.IsEmpty())
        SetVariable(wxT("GPS Full Address"), evGPS.m_strErrorMessage);
    else if (!evGPS.m_bEnabled)
        SetVariable(wxT("GPS Full Address"), wxT("GPS disabled"));
    else if (!evGPS.m_bActive)
        SetVariable(wxT("GPS Full Address"), wxT("No GPS unit detected"));
    else if (!evGPS.m_bLocked)
        SetVariable(wxT("GPS Full Address"), wxT("No GPS lock"));
    else
        SetVariable(wxT("GPS Full Address"), m_adrGPS.FormatAddress(false));

    SetVariable(wxT("GPS Speed"), FormatSpeed(evGPS.m_fSpeed));
    
    if (evGPS.m_fHeading >= 0)
        SetVariable(wxT("GPS Heading"), wxString::Format(wxT("%.0f ("), evGPS.m_fHeading) + FormatHeading(evGPS.m_fHeading) + wxT(")"));
    else
        SetVariable(wxT("GPS Heading"), wxT("?"));
        
    LibRoadnavDebug0(wxT("GPS"), wxT("Calling m_pfrmGPS->OnGPSUpdate"));
    m_pfrmGPS->OnGPSUpdate(evGPS);

    LibRoadnavDebug0(wxT("GPS"), wxT("Calling m_pfrmDirections->OnGPSUpdate"));
    m_pfrmDirections->OnGPSUpdate(evGPS, m_adrGPS);
    
    m_bOnGPSInProgress = false;

    LibRoadnavDebug0(wxT("GPS"), wxT("MapFrame::OnGPSUpdate done"));
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief Save all markers to the registry.
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::SaveMarkers()
{
    int iMarker;
    wxConfigBase * pConfig = wxConfigBase::Get();

    for (iMarker = 0; iMarker < m_ctlMap->GetMarkerCount(); iMarker++)
    {
        wxString strMarker = m_ctlMap->GetMarker(iMarker).ToString();

        pConfig->Write(wxString::Format(wxT("Marker%d"), iMarker), strMarker);
    }
    pConfig->Write(wxT("MarkerCount"), m_ctlMap->GetMarkerCount());
    pConfig->Flush();
}

//////////////////////////////////////////////////////////////////////////////
/// 
/// \brief Handles the application being closed. Terminates worker threads, 
/// saves config settings
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnClose(wxCloseEvent& event)
{
    wxRect rectWindow;
    int iDetailLevel;
    wxConfigBase * pConfig = wxConfigBase::Get();

    if (!pConfig->Read(wxT("CacheDownloads"), (long) 1))
        ClearDownloadCache();
    
#ifdef USE_SCRIPTING    
    delete m_ptmrScripting;
#endif
    
    m_pfrmGPS->Hide();
    m_pfrmDirections->Hide();
    m_pfrmWhatsNearBy->Hide();
    
    m_pfrmGPS->Destroy();
    m_pfrmDirections->Destroy();
    m_pfrmWhatsNearBy->Destroy();
    
    Hide();

    m_GPSMonitorThread->Delete();
    delete m_GPSMonitorThread;

    m_DownloadThread->ReleaseAndExit();
    delete m_DownloadThread;
    
#ifdef USE_SCRIPTING
    delete m_pScripting;
#endif

    LCDprocCleanup();

    SaveMarkers();

    Point ptCenter = m_ctlMap->GetCenterCoordinates();
    pConfig->Write(wxT("CenterLong"), ptCenter.GetLong());
    pConfig->Write(wxT("CenterLat"), ptCenter.GetLat());

    pConfig->Write(wxT("MapAngle"), m_ctlMap->GetAngle());

    pConfig->Write(wxT("DetailLevel"), m_ctlMap->GetDetailLevel() - m_iSpeedControlledDetailLevelOffset);

    m_ariRoadTypeZoomingDetailLevels[m_eRoadTypeZoomingCurrentType] = m_ctlMap->GetDetailLevel() - m_iSpeedControlledDetailLevelOffset;
    for (iDetailLevel = 0; iDetailLevel <= LAST_RECORD_TYPE; iDetailLevel++)
        pConfig->Write(wxString::Format(wxT("RoadTypeZoomingDetailLevels%d"), iDetailLevel), m_ariRoadTypeZoomingDetailLevels[iDetailLevel]);

    pConfig->Write(wxT("TrackGPSMarker"), m_bScreenTracksGPS);

    pConfig->Write(wxT("IsMaximized"), IsMaximized());

    SaveWindowPosition(this, wxT("Window"));
    SaveWindowPosition(m_pfrmGPS, wxT("GPSWindow"));
    SaveWindowPosition(m_pfrmDirections, wxT("DirectionsWindow"));
    SaveWindowPosition(m_pfrmWhatsNearBy, wxT("WhatsNearByWindow"));

    delete m_pcTTS;

    m_ctlMap->PopEventHandler(true);
    
    g_pcStringTable->Save();

    MapCleanup();

    if (pConfig->Read(wxT("EnableExitCommand"), (long) 0))
        wxExecute(pConfig->Read(wxT("ExitCommand"), GetDefaultShutdownCommand()));

    Destroy();
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief Handles running a script
///
//////////////////////////////////////////////////////////////////////////////
#ifdef USE_SCRIPTING    
void MapFrame::OnFileRunScript(wxCommandEvent & event)
{
    wxFileDialog dlg(this,
                    wxT("Run Script..."),
                    wxT(""),
                    wxT(""),
                    wxT("*.rnv"),
#if wxCHECK_VERSION(2, 8, 0)
                    wxFD_OPEN | wxFD_FILE_MUST_EXIST
#else
                    wxOPEN | wxFILE_MUST_EXIST
#endif
                    );

    if (dlg.ShowModal() == wxID_OK)
    {
        if (m_pScripting->RunFromFile(dlg.GetPath()))
        {
            wxMessageBox(wxT("Error running script"), wxT("Error"), wxOK | wxICON_ERROR, this);
        }
        else
        {
            wxMessageBox(wxT("Script run successfully"), wxT("Information"), wxOK | wxICON_INFORMATION, this);
        }
    }
}
#endif

//////////////////////////////////////////////////////////////////////////////
///
/// \brief Handles saving the shown map to a PNG file
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnFileSaveAs(wxCommandEvent & event)
{
    wxFileDialog dlg(this,
                    wxT("Save As..."),
                    wxT(""),
                    wxT(""),
                    wxT("*.png"),
#if wxCHECK_VERSION(2, 8, 0)
                    wxFD_SAVE | wxFD_OVERWRITE_PROMPT
#else
                    wxSAVE | wxOVERWRITE_PROMPT
#endif
                    );
    SaveAsSettingsDialog dlgSettings(this);

    if (dlgSettings.ShowModal() == wxID_OK)
    {
        if (dlg.ShowModal() == wxID_OK)
        {
            wxMemoryDC dc;
            wxBitmap bmpOut(dlgSettings.m_iWidth, dlgSettings.m_iHeight);
            
            dc.SelectObject(bmpOut);
            m_ctlMap->DrawAll(&dc, wxSize(dlgSettings.m_iWidth, dlgSettings.m_iHeight));
        
            bmpOut.SaveFile(dlg.GetPath(), wxBITMAP_TYPE_PNG);  
        }
    }
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief Prints the map
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnFilePrint(wxCommandEvent & event)
{
    wxString strTitle;
    Address sAddr;

    sAddr = FindCoordinates(m_ctlMap->GetCenterCoordinates(), OnlyRoadsVisibility());

    if (sAddr.m_bValid)
    {
        strTitle = sAddr.FormatAddress(false, false, true);
    }
    else
    {
        strTitle = m_ctlMap->GetCenterCoordinates().FormatPoint();
    }

    // initialize global print object if it doesn't exist yet
    if (m_pdData == NULL)
        m_pdData = new wxPrintData();

    wxPrintDialogData printDialogData(*m_pdData);
    wxPrinter printer(&printDialogData);

    Printout printout(strTitle, m_ctlMap);
    if (!printer.Print(this, &printout, TRUE))
    {
        if (wxPrinter::GetLastError() == wxPRINTER_ERROR)
            wxMessageBox(wxT("There was a problem printing.\nPerhaps your current printer is not set correctly?"), wxT("Printing"), wxOK, this);
        else
        {
            // user hit cancel
        }
    }
    else
    {
        *m_pdData = printer.GetPrintDialogData().GetPrintData();
    }
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief Brings up a print preview dialog box
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnFilePrintPreview(wxCommandEvent & event)
{
    wxString strTitle;
    Address sAddr;

    sAddr = FindCoordinates(m_ctlMap->GetCenterCoordinates(), OnlyRoadsVisibility());

    if (sAddr.m_bValid)
    {
        strTitle = sAddr.FormatAddress(false, false, true);
    }
    else
    {
        strTitle = m_ctlMap->GetCenterCoordinates().FormatPoint();
    }

    // initialize global print data if need be
    if (m_pdData == NULL)
        m_pdData = new wxPrintData();

    wxPrintDialogData printDialogData(*m_pdData);
    wxPrintPreview * preview = new wxPrintPreview(  new Printout(strTitle, m_ctlMap), 
                                                    new Printout(strTitle, m_ctlMap), 
                                                    &printDialogData);
    if (!preview->Ok())
    {
        delete preview;
        wxMessageBox(wxT("There was a problem previewing.\nPerhaps your current printer is not set correctly?"), _T("Previewing"), wxOK, this);
        return;
    }
    
    wxPreviewFrame *pfrmPreview = new wxPreviewFrame(preview, this, wxT("Print Preview"), wxPoint(100, 100), wxSize(600, 650));
    pfrmPreview->Centre(wxBOTH);
    pfrmPreview->Initialize();
    pfrmPreview->Show(TRUE);
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief File->Exit selected, close the application
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnFileExit(wxCommandEvent & event)
{
    Close(TRUE);
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief View->Compass selected, show/hide the compass
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnViewCompass(wxCommandEvent & event)
{
    m_ctlMap->ShowCompass(m_menuView->IsChecked(idViewCompass));
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief View->Aerial Photos selected, show/hide the photographic background
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnViewAerialPhotos(wxCommandEvent & event)
{
    wxConfigBase * pConfig = wxConfigBase::Get();
    
    pConfig->Write(wxT("AerialPhotosVisible"), m_menuView->IsChecked(idViewAerialPhotos));
    pConfig->Flush();

    UpdateTheme();
    m_ctlMap->ShowAerialPhotos(m_menuView->IsChecked(idViewAerialPhotos), pConfig->Read(wxT("AutoDownloadMaps"), (int) 1));

    if (m_menuView->IsChecked(idViewAerialPhotos) && m_menuView->IsChecked(idView3DMode))
    {
        wxCommandEvent ev;
        // both aerial photos and 3D mode may not be on at the same time
        m_menuView->Check(idView3DMode, false);
        OnView3DMode(ev);
    }
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief View->3D Mode selected, enable/disable 3D mode
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnView3DMode(wxCommandEvent & event)
{
    wxConfigBase * pConfig = wxConfigBase::Get();

    pConfig->Write(wxT("3DMode"), m_menuView->IsChecked(idView3DMode));
    pConfig->Flush();

    m_ctlMap->Enable3DMode(m_menuView->IsChecked(idView3DMode));

    if (m_menuView->IsChecked(idViewAerialPhotos) && m_menuView->IsChecked(idView3DMode))
    {
        wxCommandEvent ev;
        // both aerial photos and 3D mode may not be on at the same time
        m_menuView->Check(idViewAerialPhotos, false);
        OnViewAerialPhotos(ev);
    }
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief View->Scale selected, show/hide the scale key
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnViewScale(wxCommandEvent & event)
{
    m_ctlMap->ShowScale(m_menuView->IsChecked(idViewScale));
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief View->GPS History toggled
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnViewGPSHistory(wxCommandEvent & event)
{
    wxConfigBase * pConfig = wxConfigBase::Get();

    if (!m_menuView->IsChecked(idViewGPSHistory))
        m_ctlMap->ClearTrack(wxT("GPSHistory"));

    pConfig->Write(wxT("GPSHistory"), m_menuView->IsChecked(idViewGPSHistory));
    pConfig->Flush();
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief Zoom to a specified zoom level
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnViewZoomLevel(wxCommandEvent& event)
{
    m_ctlMap->SetDetailLevel(event.GetId() - idViewZoom0);
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief View->Zoom In selected, increase the detail level
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnViewZoomIn(wxCommandEvent& event)
{
    m_ctlMap->MoreDetail();
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief View->Zoom Out selected, decrease the detail level
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnViewZoomOut(wxCommandEvent& event)
{
    m_ctlMap->LessDetail();
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief View->Zoom All selected
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnViewZoomMax(wxCommandEvent& event)
{
   m_ctlMap->SetDetailLevel(m_MapAppearanceSettings.GetDetailLevelCount());
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief View->Zoom None selected
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnViewZoomMin(wxCommandEvent& event)
{
   m_ctlMap->SetDetailLevel(0);
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief Show/hide the marker indicating the current GPS coordinates
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnViewGPSMarker(wxCommandEvent& event)
{
    m_bScreenTracksGPS = m_menuView->IsChecked(idViewGPSMarker);
    SetActive(wxT("MapTracksGPS"), m_bScreenTracksGPS);
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief Toggle the marker indicating the current GPS coordinates
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnViewGPSMarkerToggle(wxCommandEvent& event)
{
    m_bScreenTracksGPS = !m_bScreenTracksGPS;
    m_menuView->Check(idViewGPSMarker, m_bScreenTracksGPS);
    SetActive(wxT("MapTracksGPS"), m_bScreenTracksGPS);
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief Show/hides the GPS status window
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnViewGPSWindow(wxCommandEvent& event)
{
    wxConfigBase * pConfig = wxConfigBase::Get();

    if (m_menuView->IsChecked(idViewGPSWindow))
        m_pfrmGPS->Show();
    else
        m_pfrmGPS->Hide();
    
    pConfig->Write(wxT("GPSWindowVisible"), m_menuView->IsChecked(idViewGPSWindow));
    pConfig->Flush();
}


//////////////////////////////////////////////////////////////////////////////
///
/// \brief Show/hides the What's Nearby window
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnViewWhatsNearByWindow(wxCommandEvent& event)
{
    if (m_menuView->IsChecked(idViewWhatsNearByWindow))
    {
        m_pfrmWhatsNearBy->SetCenter(m_ctlMap->GetCenterCoordinates());
        m_pfrmWhatsNearBy->Show();
    }
    else
    {
        m_pfrmWhatsNearBy->Hide();
    }
    
    wxConfigBase::Get()->Write(wxT("WhatsNearByWindowVisible"), m_menuView->IsChecked(idViewWhatsNearByWindow));
    wxConfigBase::Get()->Flush();
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief Enables/disables full screen mode
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::SetFullScreenMode(bool bFullScreen)
{
    ShowFullScreen(bFullScreen);
    m_menuView->Check(idViewFullScreen, IsFullScreen());
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief Enters/exits full screen mode
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnViewFullScreen(wxCommandEvent& event)
{
    SetFullScreenMode(!IsFullScreen());
}

//////////////////////////////////////////////////////////////////////////////
/// 
/// \brief Map->Set Address selected.
///
/// Bring up a dialog box asking the user for an address. Center the map on
/// that address.
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnMapSetAddress(wxCommandEvent & event)
{
    wxString strErrorMsg;
    wxString strMarkerName;
    MapMarker cMarker;
    
    if (QueryAddress(   wxT("Set Address"), 
                        this, 
                        m_ctlMap,
                        wxT(""), /* no sense including current street address */
                        m_adrGPS.m_strCityName, 
                        m_adrGPS.m_strStateName, 
                        false,
                        cMarker, 
                        &strErrorMsg) != wxID_OK)
        return;

    m_ctlMap->SetMarker(cMarker);
    
}

//////////////////////////////////////////////////////////////////////////////
/// 
/// \brief Map->Set Angle selected.
///
/// Bring up a dialog box asking the user to enter the orientation of the map.
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnMapSetAngle(wxCommandEvent & event)
{
    if (m_menuView->IsChecked(idViewAerialPhotos))
    {
        ::wxMessageBox(wxT("Sorry, maps cannot be rotated when aerial photos are enabled."),
                        wxT("Error"),
                        wxOK | wxICON_ERROR,
                        this);
        return;
    }

    wxTextEntryDialog dlg(this, wxT("Enter desired orientation in degrees"), wxT("Set Map Orientation"), wxString::Format(wxT("%.1f"), m_ctlMap->GetAngle()));

    dlg.SetValue(wxString::Format(wxT("%.1f"), m_ctlMap->GetAngle()));

    if (dlg.ShowModal() == wxID_OK)
    {
        double fAngle;

        fAngle = 0;
        dlg.GetValue().ToDouble(&fAngle);

        m_ctlMap->SetAngle(fAngle);
    }
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief Map->Waypoints selected.
///
/// Bring up the LocationDialog box, allowing the user to add/update/delete
/// waypoints.
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnMapWaypoints(wxCommandEvent & event)
{
    wxFont fntThis = GetFont();
    LocationDialog dlgAddress(this, m_ctlMap, ADFLAG_MARKERMANAGEMENTBUTTONS, &fntThis);

    dlgAddress.m_strTitle = wxT("Waypoints");

    dlgAddress.ShowModal();
    
    SaveMarkers();
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief Map->Get Directions selected.
/// Ask the user for two addresses and figure out the best way to get from
/// the first address to the second. Results are shown in the directions
/// miniframe.
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnMapGetDirections(wxCommandEvent & event)
{
    if (m_menuMap->IsChecked(idMapGetDirections))
    {
        if (!m_pfrmDirections->Setup())
            m_pfrmDirections->Show();
        else
            m_menuMap->Check(idMapGetDirections, false);
    }
    else
    {
        m_pfrmDirections->Close();
    }
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief One of the get directions accelerators has been pressed.
/// Toggle the map directions off, then on
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnMapGetDirectionsAccel(wxCommandEvent & event)
{
    if (m_menuMap->IsChecked(idMapGetDirections))
    {
        // first uncheck
        m_menuMap->Check(idMapGetDirections, 0);
        OnMapGetDirections(event);
    }

    // now check
    m_menuMap->Check(idMapGetDirections, 1);
    OnMapGetDirections(event);
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief User pressed left arrow key - move map to the left
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnMapMoveCenterLeft(wxCommandEvent & event)
{
    m_ctlMap->MoveCenterLeft();
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief User pressed right arrow key - move map to the right
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnMapMoveCenterRight(wxCommandEvent & event)
{
    m_ctlMap->MoveCenterRight();
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief User pressed up arrow key - move map to the up
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnMapMoveCenterUp(wxCommandEvent & event)
{
    m_ctlMap->MoveCenterUp();
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief User pressed down arrow key - move map to the down
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnMapMoveCenterDown(wxCommandEvent & event)
{
    m_ctlMap->MoveCenterDown();
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief Tools->Measure selected. Enables/Disables Measure mode
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnToolsMeasure(wxCommandEvent& event)
{
   if ( m_ToolMode == toolMeasure )
   {
      m_ToolMode = toolNone;
      return;
   }

   m_ToolMode = toolMeasure;
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief Updates the check mark next to Tools->Measure
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnUpdateToolsMeasure(wxUpdateUIEvent& event)
{
    event.Check( m_ToolMode == toolMeasure );
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief Tools->Zoom selected. Enables/disables zoom mode.
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnToolsZoom(wxCommandEvent& event)
{
    if ( m_ToolMode == toolZoom )
    {
        m_ToolMode = toolNone;
        return;
    }

    m_ToolMode = toolZoom;
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief Updates the check mark next to Tools->Zoom
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnUpdateToolsZoom(wxUpdateUIEvent& event)
{
    event.Check( m_ToolMode == toolZoom );
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief Tools->Download Maps selected
///
/// Bring up a dialog box listing the counties, and download the Tiger/Line
/// files for the counties the user selects. Files are pulled directly from
/// the Census Bureau web site.
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnToolsDownloadTIGERLineMaps(wxCommandEvent & event)
{
    wxFont fntThis = GetFont();
    vector<wxString> vCounties;
    vector<wxString>::iterator i;
    vector<wxString> vDownloaded;
    MapDataImporter_GNISDECI diGNIS;
    MapDataImporter_TigerLine diTigerLine;
    
    vCounties = GetCountyNames();
    
    for (i = vCounties.begin(); i != vCounties.end(); i++)
    {
        int iCountyCode;

        iCountyCode = CountyCodeByName(*i);
            
        if (diTigerLine.IsCountyLoaded(iCountyCode))
            vDownloaded.push_back(*i);
    }

    CountyDialog dlgCounty(this, &fntThis, vDownloaded);
    
    if (dlgCounty.ShowModal() == wxID_OK)
    {
        vector<wxInt32> viStateCountyCodes;
        unsigned int i;
        map<wxString, bool> mapDownloading;
        int iCount;
        int iProgressPosition;

        iCount = 0;
        for (i = 0; i < dlgCounty.m_strSelCounties.size(); i++)
        {
            int iCountyCode;
            wxString strStateAbbrev;
            
            iCountyCode = CountyCodeByName(dlgCounty.m_strSelCounties[i]);
            strStateAbbrev = StateAbbreviationByCode(iCountyCode / 1000);
            
            if (!diTigerLine.IsCountyLoaded(iCountyCode))
                iCount++;

            if (!diGNIS.IsGNISStateLoaded(strStateAbbrev) && !mapDownloading[strStateAbbrev])
            {
                mapDownloading[strStateAbbrev] = true;
                iCount++;
            }
        }
        
        if (!iCount)
        {
            ::wxMessageBox(wxT("Selected maps have already been downloaded."),
                            wxT("Error"),
                            wxOK | wxICON_ERROR,
                            this);
            return;
        }
        
        ProgressDialog dlgProgress(NULL, wxT("Downloading..."), iCount * 100);
        dlgProgress.Show();
        iProgressPosition = 0;
        for (i = 0; i < dlgCounty.m_strSelCounties.size(); i++)
        {
            int iCountyCode;
            wxString strStateAbbrev;
            MapDataImporter_GNISDECI diGNIS;
            MapDataImporter_TigerLine diTigerLine;
            
            iCountyCode = CountyCodeByName(dlgCounty.m_strSelCounties[i]);
            strStateAbbrev = StateAbbreviationByCode(iCountyCode / 1000);
            
            if (!diTigerLine.IsCountyLoaded(iCountyCode))
            {
                viStateCountyCodes.push_back(iCountyCode);
            }

            if (!diGNIS.IsGNISStateLoaded(strStateAbbrev))
            {
                diGNIS.DownloadGNISState(&m_cRecords, strStateAbbrev, &dlgProgress, iProgressPosition, 99);
                iProgressPosition += 100;
            }
        }

        MapDataImporter_TigerLine diTigerLine;
        diTigerLine.DownloadCounties(&m_cRecords, viStateCountyCodes, &dlgProgress, iProgressPosition, viStateCountyCodes.size() * 100);
        iProgressPosition += viStateCountyCodes.size() * 100;

        m_ctlMap->MapUpdated(UPDATED_DATA);
    }
}

#ifdef USE_OPENSTREETMAP
//////////////////////////////////////////////////////////////////////////////
///
/// \brief Tools->Download OSM Maps handler - download maps and import them.
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnToolsDownloadOSMMaps(wxCommandEvent & event)
{
    wxString strRtn = wxT("");
    wxStringTokenizer tkz;
    Point ptTL;
    Point ptBR;
    MapDataImporter_OSM osm;
    wxConfigBase * pConfig = wxConfigBase::Get();
    
    if (pConfig->Read(wxT("OSMUsername")) == wxT(""))
    {
        ::wxMessageBox(wxT("You must enter your OpenStreetMap username and password in Preferences before you can download any maps."),
                        wxT("Error"),
                        wxOK | wxICON_ERROR,
                        this);
        return;
    }
    
    while (strRtn == wxT(""))
    {
        strRtn = wxGetTextFromUser(wxT("Please enter the coordinate range you wish to download."),
                                    wxT("Specify Coordinates"),
                                    wxT("0 N, 0 W : 0 N, 0 W"),
                                    this);
                                    
        if (strRtn == wxT(""))
            return; // cancel pressed
        
        if (strRtn.Find(wxT(":")) < 0)
            strRtn = wxT("");

        tkz.SetString(strRtn, wxT(":"), wxTOKEN_STRTOK);
        
        ptTL.SetInvalid();
        ptTL.ParsePoint(tkz.GetNextToken());
        ptBR.SetInvalid();
        ptBR.ParsePoint(tkz.GetNextToken());
        
        if (!ptTL.IsValid() || !ptBR.IsValid())
            strRtn = wxT("");
        
        if (strRtn == wxT(""))
        {
            ::wxMessageBox( wxT("Unable to parse the coordinates you entered. Please enter two coordinates separated by a colon."),
                            wxT("Error"),
                            wxOK | wxICON_ERROR,
                            this);
        }
    }
    
    ProgressDialog dlgProgress(NULL, wxT("Downloading..."), 1000);
    dlgProgress.Show();

    if (!osm.DownloadRegion(&m_cRecords, ptTL, ptBR, pConfig->Read(wxT("OSMUsername")), pConfig->Read(wxT("OSMPassword")), &dlgProgress, 0, 1000))
        m_ctlMap->SetCenterCoordinates((ptTL + ptBR) / 2);
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief Tools->Import OSM Maps handler - import existing OSM files
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnToolsImportOSMMaps(wxCommandEvent & event)
{
    wxString strFilename;
    
    strFilename = wxFileSelector(wxT("Select OpenStreetMaps XML File"), 
                                        wxT(""),
                                        wxT(""),
                                        wxT("osm"),
                                        wxT("*.osm"),
#if wxCHECK_VERSION(2, 8, 0)
                                        wxFD_OPEN | wxFD_FILE_MUST_EXIST);
#else
                                        wxOPEN | wxFILE_MUST_EXIST);
#endif
    
    if (strFilename != wxT(""))
    {
        Point ptCenter;
        MapDataImporter_OSM osm;
        ProgressDialog dlgProgress(NULL, wxT("Importing..."), 100);
        dlgProgress.Show();

        osm.LoadDirect(strFilename, &m_cRecords, &dlgProgress, 0, 100, &ptCenter);
        
        if (ptCenter.IsValid())
            m_ctlMap->SetCenterCoordinates(ptCenter);
    }
}
#endif

//////////////////////////////////////////////////////////////////////////////
///
/// \brief Tools->Import GPS Data handler - import existing GPX files
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnToolsImportGPXData(wxCommandEvent & event)
{
    wxString strFilename;

    // Get filename
    strFilename = wxFileSelector(wxT("Select GPX File"), 
                                        wxT(""),
                                        wxT(""),
                                        wxT("gpx"),
                                        wxT("*.gpx"),
#if wxCHECK_VERSION(2, 8, 0)
                                        wxFD_OPEN | wxFD_FILE_MUST_EXIST);
#else
                                        wxOPEN | wxFILE_MUST_EXIST);
#endif
    
    if (strFilename == wxT(""))
        return;

    // Get type of data
    wxArrayString arTypes;
    int iType;
    int iMarker;

    for (iType = FIRST_RECORD_TYPE; iType < LAST_RECORD_TYPE; iType++)
        arTypes.Add(m_cRecords.GetRecordTypeDisplayName(iType));

    wxSingleChoiceDialog dlgType(   this, 
                                    wxT("Please select the type of data"), 
                                    wxT("Type of Data"),
                                    arTypes);
    if (dlgType.ShowModal() != wxID_OK)
        return;
    
    // Import data
    Point ptCenter;
    MapDataImporter_GPX gpx;
    ProgressDialog dlgProgress(NULL, wxT("Importing..."), 100);
    dlgProgress.Show();

    gpx.Load(strFilename, &m_cRecords, &dlgProgress, 0, 100, &ptCenter, (ERecordType) (dlgType.GetSelection() + FIRST_RECORD_TYPE));
        
    if (ptCenter.IsValid())
        m_ctlMap->SetCenterCoordinates(ptCenter);

    for (iMarker = 0; iMarker < gpx.MarkerCount(); iMarker++)
        m_ctlMap->SetMarker(*gpx.GetMarker(iMarker));
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief Open the preferences dialog box.
///
/// This function also restarts the GPS monitor thread, and reloads the map
/// settings if the user clicks Ok in the preferences dialog.
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnToolsPreferences(wxCommandEvent & event)
{
    //wxFont fntThis = GetFont();

    //PreferencesDialog dlgPref(this, m_ctlMap, &fntThis, &m_cRecords, &m_ThemeManager);
    
    if ( ShowOptionsDialog(this, &m_cRecords, &m_ThemeManager) == wxID_SAVE)
    {
        m_GPSMonitorThread->Delete();
        m_GPSMonitorThread = new GPSMonitorThread(this);
        m_GPSMonitorThread->Create();
        m_GPSMonitorThread->Run();

        ApplyPreferences();
    }
}

//////////////////////////////////////////////////////////////////////////////
/// 
/// \brief Help->About selected.
///
/// Show the about box.
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnHelpAbout(wxCommandEvent & event)
{
    wxDialog dlg(this, -1, wxString(wxT("About Roadnav")));
    wxBoxSizer * sizerWnd = new wxBoxSizer(wxHORIZONTAL);
    wxBoxSizer * sizerOutside = new wxBoxSizer(wxHORIZONTAL);
    wxBoxSizer * sizerInside = new wxBoxSizer(wxVERTICAL);
    wxString strLicense;

    strLicense += wxT("This program is free software; you can redistribute it and/or\n");
    strLicense += wxT("modify it under the terms of version 2 of the GNU General Public License\n");
    strLicense += wxT("as published by the Free Software Foundation.\n");
    strLicense += wxT("\n");
    strLicense += wxT("This program is distributed in the hope that it will be useful,\n");
    strLicense += wxT("but WITHOUT ANY WARRANTY; without even the implied warranty of\n");
    strLicense += wxT("MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n");
    strLicense += wxT("GNU General Public License for more details.\n");
    strLicense += wxT("\n");
    strLicense += wxT("You should have received a copy of the GNU General Public License\n");
    strLicense += wxT("along with this program (COPYING in the application folder);\n");
    strLicense += wxT("if not, write to the Free Software Foundation, Inc.,\n");
    strLicense += wxT("51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA\n");

    //////////////////////////////////////////////////////////////////////////////
    // Inside box
    //////////////////////////////////////////////////////////////////////////////
    sizerInside->Add( 
        new wxStaticText(&dlg, -1, wxT("Roadnav ") wxT(VERSION), wxDefaultPosition),
        0,
        wxALIGN_LEFT | wxALL,
        3);

    sizerInside->Add( 
        new wxStaticText(&dlg, -1, wxT("Copyright (c) 2004 - 2008 Richard L. Lynch <rllynch@users.sourceforge.net>"), wxDefaultPosition),
        0,
        wxALIGN_LEFT | wxALL,
        3);
    
    sizerInside->Add( 
        new wxStaticText(&dlg, -1, wxT("http://roadnav.sourceforge.net/"), wxDefaultPosition),
        0,
        wxALIGN_LEFT | wxALL,
        3);

    sizerInside->Add( 
        new wxStaticText(&dlg, -1, strLicense, wxDefaultPosition),
        0,
        wxALIGN_LEFT | wxALL,
        3);
    
    sizerInside->Add(new wxButton(&dlg, wxID_OK, _T("&OK")), 0, wxALL | wxALIGN_RIGHT, 5);

    //////////////////////////////////////////////////////////////////////////////
    // Outside box
    //////////////////////////////////////////////////////////////////////////////
    wxBitmap bmpAppIcon(appicon64_xpm);
    sizerOutside->Add(
        new wxStaticBitmap(&dlg, -1, bmpAppIcon),
        0,
        wxALIGN_CENTER | wxALL,
        5);

    sizerOutside->Add(
        sizerInside,
        0,
        wxALL,
        5);
    
    //////////////////////////////////////////////////////////////////////////////
    // Edge box
    //////////////////////////////////////////////////////////////////////////////

    sizerWnd->Add(
        sizerOutside,
        0,
        wxALL,
        8);
    
    dlg.SetSizer(sizerWnd);
    sizerWnd->Fit(&dlg);
    dlg.Center();
    dlg.Layout();
    dlg.ShowModal();
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief Used to test the solar timer (ctrl-t to activate)
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnSolarTimerTest(wxCommandEvent& event)
{
   wxDateTime sunrise = m_SolarTimer.GetSunrise();
   wxDateTime sunset  = m_SolarTimer.GetSunset();

   double lat,lon;
   m_SolarTimer.GetPosition(lon,lat);

   wxString msg = wxString::Format(wxT("Lat %.1f, Long %.1f\nSunrise %s\nSunset %s"),
                                    lat,lon,
                                    wx_c_str(sunrise.FormatTime()),
                                    wx_c_str(sunset.FormatTime()));

   wxMessageBox(msg);
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief Users wants to close the GPS window - uncheck the View->GPS Window menu
/// item and set registry entry GPSWindowVisible to 0.
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnGPSWindowHiding()
{
    m_menuView->Check(idViewGPSWindow, false);
    wxConfigBase::Get()->Write(wxT("GPSWindowVisible"), 0);
    wxConfigBase::Get()->Flush();
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief Users wants to close the directions window - uncheck the 
/// Map->Get Directions menu item
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnDirectionsWindowHiding()
{
    m_menuMap->Check(idMapGetDirections, false);
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief Users wants to close the what's nearby window - uncheck the 
/// View->What's Nearby Window menu item
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnWhatsNearByWindowHiding()
{
    m_menuView->Check(idViewWhatsNearByWindow, false);
    wxConfigBase::Get()->Write(wxT("WhatsNearByWindowVisible"), 0);
    wxConfigBase::Get()->Flush();
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief The center of the map has been changed somehow. Update the Whats 
/// Nearby window, if it's visible.
/// 
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnMapRecentered(wxCommandEvent & event)
{
    Address sAddr;
    wxString strAddress;
    static int iLastDetailLevel = -1;
    int iCurrentDetailLevel;

    if (m_menuView->IsChecked(idViewWhatsNearByWindow))
        m_pfrmWhatsNearBy->SetCenter(m_ctlMap->GetCenterCoordinates());

    sAddr = FindCoordinates(m_ctlMap->GetCenterCoordinates(), OnlyRoadsVisibility(), false, false, &m_cRecords);

    if (sAddr.m_bValid)
    {
        strAddress = sAddr.FormatAddress();

        strAddress.Replace(wxT("\r"), wxT(""));
        strAddress.Replace(wxT("\n"), wxT(" "));

        SetTitle(wxT("Roadnav - ") + strAddress);
    }
    else
    {
        SetTitle(wxT("Roadnav - ") + m_ctlMap->GetCenterCoordinates().FormatPoint());
    }
    
    iCurrentDetailLevel = m_ctlMap->GetDetailLevel();

    if (iCurrentDetailLevel != iLastDetailLevel)
    {
        UpdateSkinState();
        iLastDetailLevel = iCurrentDetailLevel;
    }
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief Handle the list in the Whats Nearby miniframe being double clicked by
/// centering the map on those coordinates
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnWhatsNearbyDoubleClick(wxCommandEvent & event)
{
    Point ptSel;
    
    ptSel = m_pfrmWhatsNearBy->GetSelectedCoordinates();
    
    if (ptSel.IsValid())
        m_ctlMap->SetCenterCoordinates(ptSel);
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief Cause the map to be redrawn
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::RedrawMap(wxCommandEvent & event)
{
    m_ctlMap->MapUpdated(UPDATED_DATA);
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief Returns a pointer to the map control object
///
//////////////////////////////////////////////////////////////////////////////
MapControl * MapFrame::GetMapControl()
{
    return m_ctlMap;
}

void MapFrame::InitializeThemes()
{
    // Create default themes
    // This is the one and only hard coded theme.... all the rest are
    // read from the configuration object
    MapAppearanceSettings cThemeDefaultDay;
    cThemeDefaultDay.SetMiscColor(MiscColorBackground,              ParseColor(wxT("#FFFFFF")) );
    cThemeDefaultDay.SetMiscColor(MiscColorForeground,              ParseColor(wxT("#000000")) );
    cThemeDefaultDay.SetMiscColor(MiscColorMarkerBackground,        ParseColor(wxT("#FFFF00")) );
    cThemeDefaultDay.SetMiscColor(MiscColorMarkerForeground,        ParseColor(wxT("#000000")) );
    cThemeDefaultDay.SetColor( RecordTypeDefault,                   ParseColor(wxT("#C0C0C0")) );
    cThemeDefaultDay.SetColor( RecordTypeOneWaySmallRoad,           ParseColor(wxT("#808080")) );
    cThemeDefaultDay.SetColor( RecordTypeTwoWaySmallRoad,           ParseColor(wxT("#808080")) );
    cThemeDefaultDay.SetColor( RecordTypeOneWayLargeRoad,           ParseColor(wxT("#827000")) );
    cThemeDefaultDay.SetColor( RecordTypeTwoWayLargeRoad,           ParseColor(wxT("#827000")) );
    cThemeDefaultDay.SetColor( RecordTypeOneWayHighway,             ParseColor(wxT("#B68628")) );
    cThemeDefaultDay.SetColor( RecordTypeTwoWayHighway,             ParseColor(wxT("#B68628")) );
    cThemeDefaultDay.SetColor( RecordTypeRailroad,                  ParseColor(wxT("#808080")) );
    cThemeDefaultDay.SetColor( RecordTypeWater,                     ParseColor(wxT("#0000ff")) );
    cThemeDefaultDay.SetColor( RecordTypeInvisibleLandBoundary,     ParseColor(wxT("#A0A0A0")) );
    cThemeDefaultDay.SetColor( RecordTypeInvisibleWaterBoundary,    ParseColor(wxT("#C0C0FF")) );
    cThemeDefaultDay.SetColor( RecordTypeInvisibleMiscBoundary,     ParseColor(wxT("#C0C0FF")) );
    cThemeDefaultDay.SetColor( RecordTypeLandmark,                  ParseColor(wxT("#2FAF41")) );
    cThemeDefaultDay.SetColor( RecordTypePhysicalFeature,           ParseColor(wxT("#000000")) );
    cThemeDefaultDay.SetColor( RecordTypeTownOrCity,                ParseColor(wxT("#808080")) );
    cThemeDefaultDay.SetColor( RecordTypeStateBoundary,             ParseColor(wxT("#008000")) );
    cThemeDefaultDay.SetColor( RecordTypeCountyBoundary,            ParseColor(wxT("#f0f0f0")) );
    cThemeDefaultDay.FixTextColorInsideLines();

    MapAppearanceSettings cThemeDefaultNight;
    cThemeDefaultNight.SetMiscColor(MiscColorBackground,            ParseColor(wxT("#000000")) );
    cThemeDefaultNight.SetMiscColor(MiscColorForeground,            ParseColor(wxT("#ffffff")) );
    cThemeDefaultNight.SetMiscColor(MiscColorMarkerBackground,      ParseColor(wxT("#000040")) );
    cThemeDefaultNight.SetMiscColor(MiscColorMarkerForeground,      ParseColor(wxT("#FFFFFF")) );
    cThemeDefaultNight.SetColor( RecordTypeDefault,                 ParseColor(wxT("#C0C0C0")) );
    cThemeDefaultNight.SetColor( RecordTypeOneWaySmallRoad,         ParseColor(wxT("#d0d0d0")) );
    cThemeDefaultNight.SetColor( RecordTypeTwoWaySmallRoad,         ParseColor(wxT("#d0d0d0")) );
    cThemeDefaultNight.SetColor( RecordTypeOneWayLargeRoad,         ParseColor(wxT("#cccc00")) );
    cThemeDefaultNight.SetColor( RecordTypeTwoWayLargeRoad,         ParseColor(wxT("#cccc00")) );
    cThemeDefaultNight.SetColor( RecordTypeOneWayHighway,           ParseColor(wxT("#B68628")) );
    cThemeDefaultNight.SetColor( RecordTypeTwoWayHighway,           ParseColor(wxT("#B68628")) );
    cThemeDefaultNight.SetColor( RecordTypeRailroad,                ParseColor(wxT("#808080")) );
    cThemeDefaultNight.SetColor( RecordTypeWater,                   ParseColor(wxT("#6060ff")) );
    cThemeDefaultNight.SetColor( RecordTypeInvisibleLandBoundary,   ParseColor(wxT("#A0A0A0")) );
    cThemeDefaultNight.SetColor( RecordTypeInvisibleWaterBoundary,  ParseColor(wxT("#C0C0FF")) );
    cThemeDefaultNight.SetColor( RecordTypeInvisibleMiscBoundary,   ParseColor(wxT("#C0C0FF")) );
    cThemeDefaultNight.SetColor( RecordTypeLandmark,                ParseColor(wxT("#2FAF41")) );
    cThemeDefaultNight.SetColor( RecordTypePhysicalFeature,         ParseColor(wxT("#000000")) );
    cThemeDefaultNight.SetColor( RecordTypeTownOrCity,              ParseColor(wxT("#E5E5E5")) );
    cThemeDefaultNight.SetColor( RecordTypeStateBoundary,           ParseColor(wxT("#00FF00")) );
    cThemeDefaultNight.SetColor( RecordTypeCountyBoundary,          ParseColor(wxT("#404040")) );
    cThemeDefaultNight.FixTextColorInsideLines();

    MapAppearanceSettings cThemeDefaultPhoto;
    cThemeDefaultPhoto.SetMiscColor(MiscColorBackground,            ParseColor(wxT("#808080")) );
    cThemeDefaultPhoto.SetMiscColor(MiscColorForeground,            ParseColor(wxT("#ffffff")) );
    cThemeDefaultPhoto.SetMiscColor(MiscColorMarkerBackground,      ParseColor(wxT("#000040")) );
    cThemeDefaultPhoto.SetMiscColor(MiscColorMarkerForeground,      ParseColor(wxT("#FFFFFF")) );
    cThemeDefaultPhoto.SetColor( RecordTypeDefault,                 ParseColor(wxT("#C0C0C0")) );
    cThemeDefaultPhoto.SetColor( RecordTypeOneWaySmallRoad,         ParseColor(wxT("#40ffff")) );
    cThemeDefaultPhoto.SetColor( RecordTypeTwoWaySmallRoad,         ParseColor(wxT("#40ffff")) );
    cThemeDefaultPhoto.SetColor( RecordTypeOneWayLargeRoad,         ParseColor(wxT("#ffff00")) );
    cThemeDefaultPhoto.SetColor( RecordTypeTwoWayLargeRoad,         ParseColor(wxT("#ffff00")) );
    cThemeDefaultPhoto.SetColor( RecordTypeOneWayHighway,           ParseColor(wxT("#00ff00")) );
    cThemeDefaultPhoto.SetColor( RecordTypeTwoWayHighway,           ParseColor(wxT("#00ff00")) );
    cThemeDefaultPhoto.SetColor( RecordTypeRailroad,                ParseColor(wxT("#80ff80")) );
    cThemeDefaultPhoto.SetColor( RecordTypeWater,                   ParseColor(wxT("#0000ff")) );
    cThemeDefaultPhoto.SetColor( RecordTypeInvisibleLandBoundary,   ParseColor(wxT("#A0A0A0")) );
    cThemeDefaultPhoto.SetColor( RecordTypeInvisibleWaterBoundary,  ParseColor(wxT("#C0C0FF")) );
    cThemeDefaultPhoto.SetColor( RecordTypeInvisibleMiscBoundary,   ParseColor(wxT("#C0C0FF")) );
    cThemeDefaultPhoto.SetColor( RecordTypeLandmark,                ParseColor(wxT("#2FAF41")) );
    cThemeDefaultPhoto.SetColor( RecordTypePhysicalFeature,         ParseColor(wxT("#000000")) );
    cThemeDefaultPhoto.SetColor( RecordTypeTownOrCity,              ParseColor(wxT("#E5E5E5")) );
    cThemeDefaultPhoto.SetColor( RecordTypeStateBoundary,           ParseColor(wxT("#00FF00")) );
    cThemeDefaultPhoto.SetColor( RecordTypeCountyBoundary,          ParseColor(wxT("#00ffff")) );
    cThemeDefaultPhoto.FixTextColorInsideLines();

    m_ThemeManager.AddTheme(wxT("Default-Day"), cThemeDefaultDay);
    m_ThemeManager.AddTheme(wxT("Default-Night"), cThemeDefaultNight);
    m_ThemeManager.AddTheme(wxT("Default-Photo"), cThemeDefaultPhoto);

    m_ThemeManager.SetNightTheme(wxT("Default-Night"));
    m_ThemeManager.SetDayTheme(wxT("Default-Day"));
    m_ThemeManager.SetPhotoTheme(wxT("Default-Photo"));
    
    // Load other themes from config

    // Configure MapAppearanceSettings from themes
    // (Use default for now, but change based on time of day, etc)
    m_MapAppearanceSettings = cThemeDefaultDay;

}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief Called during start up and after the user presses Ok in the 
/// preferences dialog to apply settings from the preferences dialog.
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::ApplyPreferences()
{
    wxConfigBase * pConfig = wxConfigBase::Get();

    //////////////////////////////////////////////////////////////////////////////
    // Proxy settings
    //////////////////////////////////////////////////////////////////////////////
    ConfigureProxy();

    //////////////////////////////////////////////////////////////////////////////
    // Attach to the solar timer, set the current position, and updated the
    // theme to match the time of day
    //////////////////////////////////////////////////////////////////////////////
    int zipHome;
    pConfig->Read(wxT("HomeZipCode"), &zipHome, 0);
    
    Point ptHome;
    GetZipCodeCoordinates(zipHome, &ptHome, &ptHome);
    m_SolarTimer.SetOwner(this,ptHome.GetLong(),ptHome.GetLat(),SolarTimer::Official);

    UpdateTheme();


    //////////////////////////////////////////////////////////////////////////////
    // Apply the position format
    //////////////////////////////////////////////////////////////////////////////
    wxString strPositionFormat;
    pConfig->Read(wxT("PositionFormat"), &strPositionFormat, POSITION_FORMAT_3);
    Point::SetPointFormat(strPositionFormat);


    //////////////////////////////////////////////////////////////////////////////
    // Apply the default unit format
    //////////////////////////////////////////////////////////////////////////////
    wxString strCurrentValue;
    long units;
    pConfig->Read(wxT("Units"),&units,0);
    SetDisplayUnits((EUnits)units);

    //////////////////////////////////////////////////////////////////////////////
    // Apply North Always Up settings
    //////////////////////////////////////////////////////////////////////////////
    pConfig->Read(wxT("NorthAlwaysUp"), &m_bNorthAlwaysUp, 0);
    if (m_bNorthAlwaysUp)
        m_ctlMap->SetAngle(0);


    //////////////////////////////////////////////////////////////////////////////
    // Apply drawing scale factor
    //////////////////////////////////////////////////////////////////////////////
    double fDrawingScaleFactor;
    pConfig->Read(wxT("DrawingScaleFactor"), &fDrawingScaleFactor, 1);
    m_ctlMap->SetDrawingScaleFactor(fDrawingScaleFactor);

    //////////////////////////////////////////////////////////////////////////////
    // Apply routing preferences
    //////////////////////////////////////////////////////////////////////////////
    double fPreferSmallRoads, fPreferLargeRoads, fPreferHighways;
    pConfig->Read(wxT("PreferSmallRoads"), &fPreferSmallRoads, 1);
    pConfig->Read(wxT("PreferLargeRoads"), &fPreferLargeRoads, 1.44);
    pConfig->Read(wxT("PreferHighways"), &fPreferHighways, 1.54);
    MapDataEntry_Std::SetRoutingPreferences(fPreferSmallRoads, fPreferLargeRoads, fPreferHighways);

    //////////////////////////////////////////////////////////////////////////////
    // Apply speed controlled zooming cutoffs
    //////////////////////////////////////////////////////////////////////////////
    wxString strSpeedControlledCutoffs;
    wxStringTokenizer tkzSpeedControlledCutoffs;
    bool bDone;
    
    pConfig->Read(wxT("SpeedControlledDetailLevelCutoffs"), &strSpeedControlledCutoffs, wxT("25, 50"));

    m_vSpeedControlledDetailLevelCutoffs.clear();
    tkzSpeedControlledCutoffs.SetString(strSpeedControlledCutoffs, wxT(",; "), wxTOKEN_STRTOK);
    
    bDone = false;
    while (!bDone)
    {
        wxString strToken;
        double fCutoff;
        
        strToken = tkzSpeedControlledCutoffs.GetNextToken();
        
        fCutoff = 0;
        strToken.ToDouble(&fCutoff);
        
        if (fCutoff > 1e-6)
            m_vSpeedControlledDetailLevelCutoffs.push_back(fCutoff);
        else
            bDone = true;
    }
    
#ifdef USE_SCRIPTING
    //////////////////////////////////////////////////////////////////////////////
    // Scripting settings
    //////////////////////////////////////////////////////////////////////////////
    m_pScripting->DeleteAllTCPServers();
    if (pConfig->Read(wxT("ScriptingTCPServerEnabled"), (long) 0))
        m_pScripting->AddTCPServer(pConfig->Read(wxT("ScriptingTCPServerPortNumber"), DEFAULT_SCRIPTING_TCP_PORT_NUMBER),
            pConfig->Read(wxT("ScriptingTCPServerAcceptOnlyLocal"), (long) 1));
#endif  

    //////////////////////////////////////////////////////////////////////////////
    // TTS settings
    //////////////////////////////////////////////////////////////////////////////
    delete m_pcTTS;
    
    if (pConfig->Read(wxT("TTSType"), (long) TTSTypeUseAny) == TTSTypeUseAny)
    {
        ETTSType eFoundTTSType = TTSTypeUseAny;
        int iSearchTTSType;
                
        // pick the first real TTS
        
        for (iSearchTTSType = FIRST_TTSTYPE; iSearchTTSType <= LAST_TTSTYPE && eFoundTTSType == TTSTypeNone; iSearchTTSType++)
        {
            ETTSType eSearchTTSType = (ETTSType) iSearchTTSType;
            ITTS * pcTTS;
            
            pcTTS = ConstructTTS(eSearchTTSType);
            
            if (pcTTS->Name() != wxT("None") && pcTTS->GetStatus() == ITTS::TTSStatusOK)
                eFoundTTSType = eSearchTTSType;
            
            delete pcTTS;
        }

        pConfig->Write(wxT("TTSType"), (long) eFoundTTSType);
    }
    
    m_pcTTS = ConstructTTS((ETTSType) pConfig->Read(wxT("TTSType"), (long) TTSTypeUseAny));

#ifdef LIBROADNAV_DEBUG
    //////////////////////////////////////////////////////////////////////////////
    // Debugging
    //////////////////////////////////////////////////////////////////////////////
    if (pConfig->Read(wxT("GenerateDebugLog"), (long) 0))
        LibRoadnavDebugEnable();
#endif

    // disable annoying popup errors
    m_bShowPopupGPSErrors = pConfig->Read(wxT("ShowPopupGPSErrors"), (long)0);

    //////////////////////////////////////////////////////////////////////////////
    // Autodownload maps
    //////////////////////////////////////////////////////////////////////////////
    m_ctlMap->ShowAerialPhotos(m_menuView->IsChecked(idViewAerialPhotos), pConfig->Read(wxT("AutoDownloadMaps"), (int) 1));
    
    //////////////////////////////////////////////////////////////////////////////
    // Redraw the map
    //////////////////////////////////////////////////////////////////////////////
    m_ctlMap->MapUpdated(UPDATED_THEME);
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief Converts an ID from text form to numerical form
///
//////////////////////////////////////////////////////////////////////////////
int MapFrame::MapNameToID(wxString strName)
{
    if (strName == wxT("zoomin"))
        return idViewZoomIn;

    if (strName == wxT("zoomout"))
        return idViewZoomOut;

    if (strName == wxT("save"))
        return idFileSaveAs;

    if (strName == wxT("print"))
        return idFilePrint;

    if (strName == wxT("exit"))
        return wxID_EXIT;

    if (strName == wxT("setaddress"))
        return idMapSetAddress;

    if (strName == wxT("getdirections"))
        return idMapGetDirections;

    if (strName == wxT("mapmoveleft"))
        return idMapMoveCenterLeft;

    if (strName == wxT("mapmoveright"))
        return idMapMoveCenterRight;

    if (strName == wxT("mapmoveup"))
        return idMapMoveCenterUp;

    if (strName == wxT("mapmovedown"))
        return idMapMoveCenterDown;

    if (strName == wxT("downloadmaps"))
        return idToolsDownloadMaps;

    if (strName == wxT("preferences"))
        return wxID_PREFERENCES;

    if (strName == wxT("zoom0"))
        return idViewZoom0;

    if (strName == wxT("zoom1"))
        return idViewZoom1;

    if (strName == wxT("zoom2"))
        return idViewZoom2;

    if (strName == wxT("zoom3"))
        return idViewZoom3;

    if (strName == wxT("zoom4"))
        return idViewZoom4;

    if (strName == wxT("zoom5"))
        return idViewZoom5;

    if (strName == wxT("zoom6"))
        return idViewZoom6;

    if (strName == wxT("zoom7"))
        return idViewZoom7;

    if (strName == wxT("zoom8"))
        return idViewZoom8;

    if (strName == wxT("zoom9"))
        return idViewZoom9;

    if (strName == wxT("zoom10"))
        return idViewZoom10;

    if (strName == wxT("zoom11"))
        return idViewZoom11;

    if (strName == wxT("zoom12"))
        return idViewZoom12;

    if (strName == wxT("zoom13"))
        return idViewZoom13;

    if (strName == wxT("zoom14"))
        return idViewZoom14;
        
    if (strName == wxT("MapTracksGPS"))
        return idViewGPSMarker;

    return -1;
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief Escape key pressed. Exit full screen mode if FS mode active,
/// otherwise, do nothing.
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnEscapeKey(wxCommandEvent & event)
{
    if (!IsFullScreen())
        return;
        
    OnViewFullScreen(event);    
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief Creates the control named strName and make it available to the
/// skin using AddNamedControl.
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::CreateNamedControl(wxString strName)
{
    if (strName == wxT("compass") && !m_pctlCompass)
    {
        m_pctlCompass = new CompassControl(this);
        AddNamedControl(m_pctlCompass, wxT("compass"));
    }
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief Deletes a control that had been created in CreateNamedControl
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::DeleteNamedControl(wxString strName, wxControl * pControl)
{
    if (strName == wxT("compass"))
    {
        delete m_pctlCompass;
        m_pctlCompass = NULL;
    }

    if (strName == wxT("map"))
    {
        AddNamedControl(m_ctlMap, wxT("map"));
    }
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief User has right clicked on the map control - download the county
/// under the cursor.
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::OnDownloadCounty(wxCommandEvent & ev)
{
    wxString strStateAbbrev;
    int iCount;
    int iProgressPosition;
    MapDataImporter_GNISDECI diGNIS;
    MapDataImporter_TigerLine diTigerLine;
    int iCountyCode;

    if (!wxConfigBase::Get()->Read(wxT("AutoDownloadMaps"), (int) 1))
        return;

    iCountyCode = ev.GetInt();

    iCount = 0;
    iProgressPosition = 0;

    strStateAbbrev = StateAbbreviationByCode(iCountyCode / 1000);
            
    if (!diTigerLine.IsCountyLoaded(iCountyCode))
        iCount += 100;

    if (!diGNIS.IsGNISStateLoaded(strStateAbbrev))
        iCount += 100;

    if (!iCount)
        return;

    ProgressDialog dlgProgress(NULL, wxT("Downloading..."), iCount);
    dlgProgress.Show();

    if (!diTigerLine.IsCountyLoaded(iCountyCode))
    {
        diTigerLine.DownloadCounty(&m_cRecords, iCountyCode, &dlgProgress, iProgressPosition, 100);
        iProgressPosition += 100;
    }
    if (!diGNIS.IsGNISStateLoaded(strStateAbbrev))
    {
        diGNIS.DownloadGNISState(&m_cRecords, strStateAbbrev, &dlgProgress, iProgressPosition, 100);
        iProgressPosition += 100;
    }
    m_ctlMap->MapUpdated(UPDATED_DATA);
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief Update a variable in the skin and LCD output.
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::SetVariable(wxString strName, wxString strValue)
{
    SetNamedText(strName, strValue);
    LCDprocSetText(strName, strValue);
}

//////////////////////////////////////////////////////////////////////////////
///
/// \brief Updates the active state of all of the skin buttons
///
//////////////////////////////////////////////////////////////////////////////
void MapFrame::UpdateSkinState()
{
    int iDL;
    int nDetailLevels;
    int iCurrentDetailLevel;

    iCurrentDetailLevel = m_ctlMap->GetDetailLevel();
    nDetailLevels = m_ctlMap->GetDetailLevelCount();

    for (iDL = 0; iDL < nDetailLevels; iDL++)
        SetActive(wxString::Format(wxT("zoom%d"), iDL), iDL == iCurrentDetailLevel);
    
    SetActive(wxT("MapTracksGPS"), m_bScreenTracksGPS);
}

ITTS * MapFrame::GetTTS()
{
    return m_pcTTS;
}

---