frame.cpp

/***************************************************************************
                           frame.cpp
                           -------------------
    begin                : 2004-05-24 21:59
    copyright            : (C) 2004-2005 by Michael Menne
    email                : menne@users.sourceforge.net
 ***************************************************************************/

/***************************************************************************
 This program is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License
 as published by the Free Software Foundation; either version 2
 of the License, or (at your option) any later version.

 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 ***************************************************************************/

#include "app.h"
#include "dlgabout.h"
#include "dlgeditprofile.h"
#include "dlgfind.h"
#include "dlggoto.h"
#include "dlgpath.h"
#include "dlgprofilemanager.h"
#include "dlgupdate.h"
#include "frame.h"
#include "glcanvas.h"
#include "map.h"
#include "profilemanager.h"

#include <wx/splash.h>
#include <wx/textdlg.h>
#include <wx/toolbar.h>
#include <wx/tooltip.h>
#include <wx/valtext.h> // wxValidator


extern ofstream logFile;

namespace WDS
{

BEGIN_EVENT_TABLE(CFrame, wxFrame)
    EVT_MENU( wxID_EXIT,  CFrame::OnQuit )
    EVT_MENU( wxID_OPEN,  CFrame::OnOpen )
    EVT_MENU( wxID_NEW ,  CFrame::OnNew )
    EVT_MENU( wxID_CLOSE, CFrame::OnClose )

    EVT_MENU( IDM_EDIT_PROFILES, CFrame::OnEditProfiles )
    EVT_MENU( IDM_UPDATE, CFrame::OnUpdateClient )

    EVT_MENU( IDM_ZOOM_IN,    CFrame::OnZoomIn  )
    EVT_MENU( IDM_ZOOM_OUT,   CFrame::OnZoomOut )
    EVT_COMBOBOX(IDC_CB_ZOOM, CFrame::OnCbZoom  )

    EVT_MENU( IDM_FOGOFWAR,   CFrame::OnMenuFogOfWar )
    EVT_MENU( IDM_FULLSCREEN, CFrame::OnMenuFullScreen )
    EVT_MENU( IDM_TOOLBAR,    CFrame::OnMenuToolbar    )
    EVT_MENU( IDM_STATUSBAR,  CFrame::OnMenuStatusbar  )

    EVT_MENU( IDM_GOTO, CFrame::OnMenuGoTo )
    EVT_MENU( IDM_SEARCH, CFrame::OnMenuFind )
    EVT_MENU( IDM_ABOUT, CFrame::OnMenuAbout )

    EVT_RIGHT_UP( CFrame::OnRButtonUp )
    EVT_MOTION( CFrame::OnMouseMove )
    EVT_MOUSEWHEEL( CFrame::OnMouseWheel )
    EVT_KEY_DOWN( CFrame::OnKeyDown )
    EVT_MENU( IDM_PATH_START, CFrame::OnPathStart )
    EVT_MENU( IDM_PATH_END,   CFrame::OnPathEnd )
    EVT_MENU( IDM_ADD_TO_FAVOURITES, CFrame::OnAddToFavourites )
END_EVENT_TABLE()

/*----------------------------------------------------------------------------/
    Constructor / Destructor
-----------------------------------------------------------------------------*/

CFrame::CFrame(const wxChar *title, int xpos, int ypos, int width, int height)
    : wxFrame((wxFrame *) NULL, -1, title, wxPoint(xpos, ypos), wxSize(width, height)),
    m_pMap(0), m_pDlgFind(0)
{
    // Menue
    InitMenu( );

    // Status Bar
    SetMenuBar( m_pMenuBar );

    // Icon
    SetIcon( wxIcon ( "./data/icons/wdsmap.ico", wxBITMAP_TYPE_ICO ) );

    // ToolBar Initialisieren
    InitToolBar( );

    // OpenGL Canvas
    m_pCanvas = new CGLCanvas( this );
    m_pCanvas->SetNextHandler( this );

    // Search dialog
    m_pDlgFind = new CDlgFind(this);

    // Statusbar
    const int nFields = 2;
    CreateStatusBar(nFields);
    SetStatusText("Ready", 0);
    int aWidths[nFields] = {  -1, 150 };
    SetStatusWidths( nFields, aWidths );

    // Acceleration Table; NOTE: notwendig fuer Linux!
    wxAcceleratorEntry entries[3];
    entries[0].Set( wxACCEL_CTRL, (int) 'G', IDM_GOTO );
    entries[1].Set( wxACCEL_CTRL, (int) 'F', IDM_SEARCH );
    entries[2].Set( wxACCEL_CTRL, (int) 'O', wxID_OPEN );
    wxAcceleratorTable accel( 3, entries );
    SetAcceleratorTable( accel );

    // Sonstige Variable
    m_bPathStart = false;   // Fuer Pathfind
}

CFrame::~CFrame()
{
    CProfile *pProfile = CProfileManager::GetCurrentProfile( );
    if( pProfile )
    {
        pProfile->SetLastScrollPosition( m_pCanvas->GetXPos(),
                                         m_pCanvas->GetYPos() );
        pProfile->SetLastZoom( m_pCanvas->GetZoom() );
    }

    // Suchen Dialog loeschen
    if( m_pDlgFind )
        delete m_pDlgFind;

    // Karte loeschen
    if( m_pMap )
        delete m_pMap;

    // Aktuelle Breite und Hoehe des Frames in der Configdatei speichern
    wxSize szFrameSize = this->GetSize();
    wxConfigBase::Get()->SetPath( "/General" );
    wxConfigBase::Get()->Write( "window_width",     szFrameSize.GetWidth()  );
    wxConfigBase::Get()->Write( "window_height",    szFrameSize.GetHeight() );
    wxConfigBase::Get()->Write( "window_maximized", this->IsMaximized() );

    // Graphiken freigeben
    CTile::Shut();
}

/*----------------------------------------------------------------------------/
    Member Functions
-----------------------------------------------------------------------------*/

void CFrame::InitMenu( )
{
    // Menue erzeugen
    m_pMenuBar = new wxMenuBar();

    // File menu
    m_pFileMenu = new wxMenu();
    //m_pFileMenu->Append(wxID_OPEN, "&Open...\tCtrl+O", "Open an existing map file.");
    m_pFileMenu->Append(wxID_NEW, "&Neues Profil...\tCtrl+N", "Erstellt ein neues Profil.");
    m_pFileMenu->AppendSeparator();
    m_pFileMenu->Append(IDM_EDIT_PROFILES, "Profile b&earbeiten...\tCtrl+E", "Profile erstellen, bearbeiten, löschen und wechseln.");
    m_pFileMenu->AppendSeparator();
    m_pFileMenu->Append(wxID_EXIT, "&Beenden", "WDSMap beenden.");
    m_pMenuBar->Append(m_pFileMenu, "&Datei");

    // Funktions menu
    m_pFuncMenu = new wxMenu();
    m_pFuncMenu->Append( IDM_GOTO, "&GoTo...\tCtrl+G", "Zu einer andere x:y-Position springen." );
    m_pFuncMenu->Append( IDM_SEARCH, "&Suchen...\tCtrl+F", "Spieler, Gilden und Städte suchen." );
    m_pFuncMenu->AppendSeparator();
    m_pFuncMenu->Append( IDM_UPDATE, "&Update\tCtrl+U", "Karten-Update vom phpmap server durchführen." );
    m_pMenuBar->Append( m_pFuncMenu, "&Tools" );

    // View menu
    m_pViewMenu = new wxMenu();
    m_pViewMenu->Append( IDM_TOOLBAR,   "&Toolbar",   "Show / hide the toolbar.",   wxITEM_CHECK );
    m_pViewMenu->Append( IDM_STATUSBAR, "&Statusbar", "Show / hide the statusbar.", wxITEM_CHECK );
    m_pViewMenu->AppendSeparator();
    m_pViewMenu->Append( IDM_FOGOFWAR,   "&Fog of War",    "Fog of War (Nebel des Krieges) zeigen.", wxITEM_CHECK );
    m_pViewMenu->Append( IDM_FULLSCREEN, "&Vollbild\tF11", "In den Vollbildmodus wechseln.", wxITEM_CHECK );
    m_pMenuBar->Append( m_pViewMenu, "&Ansicht" );

    // About menu
    m_pInfoMenu = new wxMenu();
    m_pInfoMenu->Append(IDM_ABOUT, "&About...", "Informationen über die WDSMap.");
    m_pMenuBar->Append(m_pInfoMenu, "I&nfo");


    // Im View-Menue "Toolbar" und "Statusbar" markieren
    m_pViewMenu->FindItem(IDM_TOOLBAR  )->Check( true );
    m_pViewMenu->FindItem(IDM_STATUSBAR)->Check( true );

    // FogOfWar markieren, wenn der Spieler es angeschaltet hat
    CProfile *pProfile = CProfileManager::GetCurrentProfile( );
    if ( pProfile ) {
        m_pViewMenu->FindItem(IDM_FOGOFWAR  )->Check( pProfile->GetFogOfWar() );
    }
}

void CFrame::InitToolBar( )
{
    // ToolBar erzeugen
    long style = wxNO_BORDER | wxTB_HORIZONTAL | wxTB_FLAT; // | wxTB_TEXT | wxTB_NOICONS;
    wxToolBar *pToolBar = CreateToolBar( style, IDT_TOOLBAR );

    // Bildresourcen laden
    wxBitmap toolBarBitmaps[12];
    wxImage img;
    img.LoadFile( "./data/icons/new.png"          ); toolBarBitmaps[ 0] = wxBitmap( img );
    img.LoadFile( "./data/icons/open.png"         ); toolBarBitmaps[ 1] = wxBitmap( img );
    img.LoadFile( "./data/icons/close.png"        ); toolBarBitmaps[ 2] = wxBitmap( img );
    img.LoadFile( "./data/icons/profiles.png"     ); toolBarBitmaps[ 3] = wxBitmap( img );
    img.LoadFile( "./data/icons/search.png"       ); toolBarBitmaps[ 4] = wxBitmap( img );
    img.LoadFile( "./data/icons/zoomout.png"      ); toolBarBitmaps[ 5] = wxBitmap( img );
    img.LoadFile( "./data/icons/zoomin.png"       ); toolBarBitmaps[ 6] = wxBitmap( img );
    img.LoadFile( "./data/icons/goto.png"         ); toolBarBitmaps[ 7] = wxBitmap( img );
    img.LoadFile( "./data/icons/fogofwar.png"     ); toolBarBitmaps[ 8] = wxBitmap( img );
    img.LoadFile( "./data/icons/fullscreen.png"   ); toolBarBitmaps[ 9] = wxBitmap( img );
    img.LoadFile( "./data/icons/nofullscreen.png" ); toolBarBitmaps[10] = wxBitmap( img );
    img.LoadFile( "./data/icons/about.png"        ); toolBarBitmaps[11] = wxBitmap( img );

    // Zoom Combobox erstellen und fuellen
    m_pCbZoom = new wxComboBox( pToolBar, IDC_CB_ZOOM, "", wxDefaultPosition, wxSize(80,-1) );
    m_pCbZoom->Append( "10%",  (void*) 10  );
    m_pCbZoom->Append( "20%",  (void*) 20  );
    m_pCbZoom->Append( "30%",  (void*) 30  );
    m_pCbZoom->Append( "50%",  (void*) 50  );
    m_pCbZoom->Append( "70%",  (void*) 70  );
    m_pCbZoom->Append( "80%",  (void*) 80  );
    m_pCbZoom->Append( "90%",  (void*) 90  );
    m_pCbZoom->Append( "100%", (void*) 100 );
    m_pCbZoom->Append( "150%", (void*) 150 );
    m_pCbZoom->Append( "200%", (void*) 200 );
    m_pCbZoom->Append( "250%", (void*) 250 );
    m_pCbZoom->Append( "300%", (void*) 300 );
    m_pCbZoom->Append( "400%", (void*) 400 );
    m_pCbZoom->SetSelection( m_pCbZoom->FindString( "100%" ) );

    // Groese der Toolbar-Bitmaps angeben
    pToolBar->SetToolBitmapSize( wxSize(22, 22) );

    // Tools zur Toolbar hinzufuegen
    pToolBar->AddTool( wxID_NEW,     toolBarBitmaps[0], "Neues Profil",  "Ein neues Profil erstellen." );
    pToolBar->AddTool( wxID_OPEN,    toolBarBitmaps[1], "Datei öffnen...", "Eine Map-Datei öffnen." );
    pToolBar->AddTool( wxID_CLOSE,   toolBarBitmaps[2], "Profil schließen", "Aktuelles Profil schließen." );
    pToolBar->AddTool( IDM_EDIT_PROFILES, toolBarBitmaps[3], "Profile bearbeiten", "Profile erstellen, bearbeiten, löschen und wechseln.");
    pToolBar->AddSeparator();
    pToolBar->AddTool( IDM_SEARCH,   toolBarBitmaps[4], "Suchen",      "Spieler, Gilden und Städte suchen." );
    pToolBar->AddSeparator();
    pToolBar->AddTool( IDM_ZOOM_OUT, toolBarBitmaps[5], "Verkleinern", "Sichtbereich vergrößern." );
    pToolBar->AddControl( m_pCbZoom );
    pToolBar->AddTool( IDM_ZOOM_IN,  toolBarBitmaps[6], "Vergrößern",  "Sichtbereich verkleinern." );
    pToolBar->AddSeparator();
    pToolBar->AddTool( IDM_GOTO,     toolBarBitmaps[7], "Go To",       "Zu einer andere x:y-Position springen." );
    pToolBar->AddSeparator();
    pToolBar->AddTool( IDM_FOGOFWAR, "", toolBarBitmaps[8], toolBarBitmaps[8], wxITEM_CHECK, "Fog of War", "Fog of War (Nebel des Krieges) zeigen." );
    pToolBar->AddSeparator();
    pToolBar->AddTool( IDM_FULLSCREEN, "", toolBarBitmaps[9], toolBarBitmaps[10], wxITEM_CHECK, "Vollbild", "In den Vollbildmodus wechseln." );
    pToolBar->AddSeparator();
    pToolBar->AddTool( IDM_ABOUT,    toolBarBitmaps[11], "About", "Informationen über die WDSMap." );

    // after adding the buttons to the toolbar, must call Realize() to reflect the changes
    pToolBar->Realize();

    // as in InitMenu: if necessary, enable FogOfWar
    CProfile *pProfile = CProfileManager::GetCurrentProfile( );
    if ( pProfile ) {
        pToolBar->ToggleTool( IDM_FOGOFWAR, pProfile->GetFogOfWar() );
    }
}

void CFrame::Init( )
{
    // OpenGL Initialisieren
    m_pCanvas->Init();

    // Splash Screen anzeigen während die Graphiken geladen werden
    wxSplashScreen *pSplash = NULL;

    wxBitmap bitmap;
    if( bitmap.LoadFile("data/about.png", wxBITMAP_TYPE_PNG) )
    {
        pSplash = new wxSplashScreen(bitmap, wxSPLASH_CENTRE_ON_SCREEN, 0, NULL, -1 );
    }

    // Graphiken laden
    CTile::Init();

    // Splash Screen entfernen
    if( pSplash )
        delete pSplash;

    // Karte laden
    CProfile *pProfile = CProfileManager::GetCurrentProfile( );
    if( pProfile && pProfile->IsValid() )
    {
        LoadProfile( pProfile );
        UpdateCbZoom( );
    } else if ( wxGetApp().GetProfileManager()->size() == 0 ) {
        // TODO: most probably first start of program, so popup "New Profile"-dialog
    }

    // Canvas updaten, da neue Karte geladen wurde
    m_pCanvas->UpdateView();
}

void CFrame::SetFullScreen( bool bFull )
{
    if( bFull == IsFullScreen() )
        return;

    ShowFullScreen( bFull, wxFULLSCREEN_NOMENUBAR | wxFULLSCREEN_NOBORDER  |
                           wxFULLSCREEN_NOCAPTION | wxFULLSCREEN_NOSTATUSBAR ); // wxFULLSCREEN_NOTOOLBAR;
    m_pViewMenu->Check( IDM_FULLSCREEN, bFull );
    GetToolBar()->ToggleTool(IDM_FULLSCREEN, bFull);
}

void CFrame::SwitchProfile( CProfile* newProfile )
{
    if( newProfile == CProfileManager::GetCurrentProfile( ) )
        return;

    if ( CProfile* profile = CProfileManager::GetCurrentProfile() ) {
        // NOTE: Save profile data here (ways, gotos, notes etc)
        // right now, there is nothing to save! yay jo!
        profile->SetLastScrollPosition( m_pCanvas->GetXPos(), m_pCanvas->GetYPos() );
        profile->SetLastZoom( m_pCanvas->GetZoom() );
    }

    // Alte Karte loeschen
    if( m_pMap )
        delete m_pMap;

    CProfileManager::SetCurrentProfile( newProfile );

    // Kartendaten laden
    if( newProfile && newProfile->IsValid() ) {
        LoadProfile( newProfile );
    } else {
        m_pMap = NULL;

        // Zoom auf 1.0 setzen
        m_pCanvas->SetZoom( 1.0f );
        // Zu Ausgangsposition scrollen
        m_pCanvas->ScrollTo( 0, 0 );
    }

    UpdateCbZoom( );

    // Pfadanfang zurücksetzen
    m_bPathStart = false;

    // Canvas updaten
    m_pCanvas->UpdateView();
}

void CFrame::LoadProfile( CProfile* newProfile )
{
    // NOTE: call SezZoom BEFORE SetXYPos, as XYPos rely on the zoom
    m_pCanvas->SetZoom( newProfile->GetLastZoom() );
    m_pCanvas->SetXYPos( newProfile->GetLastScrollPositionX(),
                         newProfile->GetLastScrollPositionY() );

    m_pMap = new CMap( );
    m_pMap->Load( newProfile->GetMap(), newProfile->GetDat() );
}

void CFrame::GoTo( int x, int y )
{
    if( m_pMap && m_pMap->IsValidField( x, y ) )
    {
        wxPoint pt = m_pMap->GetPosFromField( x, y );
        m_pCanvas->ScrollTo( pt.x, pt.y );
        CProfileManager::GetCurrentProfile()->AddRecentGoTo( x, y );
    }
    else
    {
        wxMessageBox( wxString::Format( "Feld %d:%d existiert nicht!", x, y ),
                      "Fehler - WDSMap", wxOK | wxCENTER | wxICON_ERROR );
    }
}

//
//BEGIN EVENT HANDLER
//
void CFrame::OnQuit( wxEvent& event )
{
    Close( true );
}

/*
 *  OnNew( )
 *  Zeigt einen Dialog an mit dem der Nutzer eine neue Karte laden kann
 *  Erzeugt neues Profil, wenn OK geklickt wird.
 */
void CFrame::OnNew  ( wxEvent &event )
{
    CProfile *pProfile = new CProfile( );

    CDlgEditProfile dlg( this, CDlgEditProfile::ADD, pProfile );
    dlg.Center();
    if( dlg.ShowModal() == wxID_OK )
    {
        wxGetApp().GetProfileManager()->AddProfile( pProfile );

        // switch profile
        SwitchProfile( pProfile );
    } else {
        delete pProfile;
    }
}

void CFrame::OnOpen( wxEvent &event )
{
}

void CFrame::OnClose( wxEvent &event )
{
    // Pruefen ob eine Karte geladen ist
    if( m_pMap == NULL )
        return;

    // if map is not NULL, then we have a profile
    CProfile* p = CProfileManager::GetCurrentProfile();
    // Benutzer frage, ob er wirklich die Karte schliessen will
    wxMessageDialog dlg( this, "Profil \"" + p->GetName() + "\" wirklich schließen?",
                               "Map schließen - WDSMap",
                               wxYES_NO | wxCENTRE | wxICON_QUESTION );

    if( dlg.ShowModal() == wxID_YES ) {
        SwitchProfile( 0L );
    }
}

void CFrame::OnEditProfiles( wxEvent &event )
{
    CDlgProfileManager dlg( this );
    dlg.Center( );

    // show modal, no need to test for wxID_OK for now
    dlg.ShowModal();
}

void CFrame::OnZoomIn( wxEvent &event )
{
    m_pCanvas->ZoomIn( );
    UpdateCbZoom( );
}

void CFrame::OnZoomOut( wxEvent &event )
{
    m_pCanvas->ZoomOut( );
    UpdateCbZoom( );
}

void CFrame::OnCbZoom( wxCommandEvent& event )
{
    int nSel = event.GetSelection( );
    int nPercent = (int) m_pCbZoom->GetClientData( nSel );
    m_pCanvas->SetZoom( nPercent / 100.0f );
}

void CFrame::UpdateCbZoom()
{
    float fZoom  = m_pCanvas->GetZoom();
    int nPercent = (((int)(fZoom * 100) + 2) / 10) * 10;    // Rundungsfehler auffangen!
    m_pCbZoom->SetValue( wxString::Format( "%d%%", nPercent ) );
}

void CFrame::OnMenuGoTo( wxEvent &event )
{
    if ( m_pMap ) {
        CDlgGoTo dlg( this );
        dlg.Center();
        if( dlg.ShowModal() == wxID_OK ) {
            int x = dlg.GetX();
            int y = dlg.GetY();

            GoTo( x, y );
        }
    } else {
        wxMessageBox( "Es muss zuerst eine Map geladen werden.", "Fehler - WDSMap",
                      wxOK | wxCENTER | wxICON_ERROR );
    }
}

void CFrame::OnMenuFind( wxEvent &event )
{
    m_pDlgFind->Center();
    m_pDlgFind->Show( );    // Modeless anzeigen
}

void CFrame::OnMenuFogOfWar( wxCommandEvent &event )
{
    bool bFOW = event.IsChecked( );

    // Wert im Profil setzen
    CProfile* profile = CProfileManager::GetCurrentProfile( );
    if ( profile ) {
        profile->SetFogOfWar( bFOW );

        // Karte neu zeichnen
        m_pCanvas->Refresh( );

        m_pViewMenu->Check( IDM_FOGOFWAR, bFOW );
        GetToolBar()->ToggleTool(IDM_FOGOFWAR, bFOW);
    }
}

void CFrame::OnMenuFullScreen( wxCommandEvent &event )
{
    SetFullScreen( !IsFullScreen() );
}

void CFrame::OnMenuToolbar( wxCommandEvent &event )
{
    // Toolbar ein/ausblenden
    GetToolBar()->Show( event.IsChecked() );
    SendSizeEvent( );
}

void CFrame::OnMenuStatusbar( wxCommandEvent &event )
{
    // Statusbar ein/ausblenden
    GetStatusBar()->Show( event.IsChecked() );
    SendSizeEvent( );
}

void CFrame::OnMenuAbout( wxEvent &event )
{
    // About Dialog anzeigen
    CDlgAbout dlgAbout( this );
    dlgAbout.Center();
    dlgAbout.ShowModal();
}

void CFrame::OnUpdateClient( wxEvent &event )
{
    CDlgUpdate dlg( this, CProfileManager::GetCurrentProfile() );
    dlg.Center();
    if( dlg.ShowModal() == wxID_OK )
    {
        string strUpdate = dlg.GetUpdateString( );

        // Karte updaten
        m_pMap->Update( strUpdate );

        // Karte neu zeichnen
        m_pCanvas->Refresh( );
    }
}

void CFrame::OnMouseMove( wxMouseEvent &event )
{
    static wxPoint ptOldField(-1, -1);

    // Pruefen ob eine Karte geladen ist
    if( m_pMap )
    {
        // Feld unter dem Mousecursor berechnen
        wxPoint pt( event.GetX(), event.GetY() );
        m_pCanvas->ClientToOpenGL( pt );
        wxPoint ptField = m_pMap->GetFieldAtPoint( pt.x, pt.y );

        if( ptField != ptOldField )
        {
            wxString str = wxString::Format( "X: %d, Y: %d", ptField.x, ptField.y );

            // Statusbar updaten
            SetStatusText( str, 1 );

#ifdef SHOW_TOOLTIPS
            // ToolTip der Canvas aktualisieren
            m_pCanvas->GetToolTip()->SetTip( str );
#endif

            ptOldField = ptField;
        }
    }
#ifdef SHOW_TOOLTIPS
    // ToolTip beenden wenn sich Maus bewegt
    // Problem: In 20 % wird kein Tooltip angezeigt ( dann wenn % == 0 )
    // TODO: Das hier ist noch verbesserungswuerdig! Geht nicht unter Linux.
    static int n = 0;
    if( n++ % 5 == 0 )
    {
        wxToolTip::Enable( false );
        wxToolTip::Enable( true );
    }
#endif
}

void CFrame::OnMouseWheel( wxMouseEvent &event )
{
    int nRot = event.GetWheelRotation();
    if( nRot > 0 )
    {
        m_pCanvas->ZoomIn( );
    }
    else if( nRot < 0 )
    {
        m_pCanvas->ZoomOut( );
    }

    UpdateCbZoom();
}

void CFrame::OnKeyDown( wxKeyEvent &event )
{
    switch( event.GetKeyCode() )
    {
    case WXK_ESCAPE:
        if( IsFullScreen() )        // Bei ESC Fullscreen beenden
            SetFullScreen( false );
        break;

    case WXK_F11:
        SetFullScreen( !IsFullScreen() );
        break;

    case WXK_NUMPAD_ADD:
    case '+':
        m_pCanvas->ZoomIn();
        UpdateCbZoom();
        break;

    case WXK_NUMPAD_SUBTRACT:
    case '-':
        m_pCanvas->ZoomOut();
        UpdateCbZoom();
        break;
    }
}

void CFrame::OnRButtonUp( wxMouseEvent &event )
{
    // Kontextmenü nur anzeigen wenn eine Karte geladen ist
    if( m_pMap == NULL )
        return;

    // Kontextmenu erzeugen
    wxMenu menu;
    menu.Append( IDM_ADD_TO_FAVOURITES, "&Bookmark" );
    menu.AppendSeparator( );
    menu.Append( IDM_PATH_START, "Pfad&anfang" );
    menu.Append( IDM_PATH_END,   "Pfad&ende"   );

    // Wenn kein Startpunkt gesetzt ist, Pfadende deaktiveren
    if( m_bPathStart == false )
        menu.Enable( IDM_PATH_END, false );

    // Letzte Mausposition speichern
    m_ptLastMousePos.x = event.GetX();
    m_ptLastMousePos.y = event.GetY();

    // Popup Menue anzeigen
    PopupMenu( &menu, event.GetX(), event.GetY() );
}

void CFrame::OnPathStart( wxEvent &event )
{
    // Pruefen ob Karte geladen
    if( !m_pMap )
        return;

    // x/y Koordinate des Feldes unter dem Cursor ermitteln
    int x = m_ptLastMousePos.x;
    int y = m_ptLastMousePos.y;
    m_pCanvas->ClientToOpenGL( x, y );
    m_ptPathStart = m_pMap->GetFieldAtPoint( x, y );

    // Startpunkt gesetzt
    m_bPathStart = true;
}

void CFrame::OnPathEnd( wxEvent &event )
{
    // Pruefen ob Karte geladen und ein Startpunkt gesetzt wurde
    if( !m_pMap || !m_bPathStart )
        return;

    // x/y Koordinate des Feldes unter dem Cursor ermitteln
    int x = m_ptLastMousePos.x;
    int y = m_ptLastMousePos.y;
    m_pCanvas->ClientToOpenGL( x, y );
    m_ptPathEnd  = m_pMap->GetFieldAtPoint( x, y );

    // Pfad finden
    m_pMap->FindPath( m_ptPathStart.x, m_ptPathStart.y,
                      m_ptPathEnd.x, m_ptPathEnd.y );
}

void CFrame::OnAddToFavourites( wxEvent &event )
{
    if( m_pMap ) {
        // get x/y position
        int x = m_ptLastMousePos.x;
        int y = m_ptLastMousePos.y;
        m_pCanvas->ClientToOpenGL( x, y );
        wxPoint pt = m_pMap->GetFieldAtPoint( x, y );

        CProfile* profile = CProfileManager::GetCurrentProfile();

        if ( m_pMap->IsValidField( pt.x, pt.y )  && profile) {
            wxTextEntryDialog dlg( this, "Beschreibung eingeben:" );
            if ( dlg.ShowModal() == wxID_OK ) {
                // '\n' is separator, so force a replace
                string lf = "\n";
                string space = " ";
                wxString tmp = dlg.GetValue();
                tmp.Replace( lf.c_str(), space.c_str() );

                profile->AddBookmark( pt.x, pt.y, tmp );
            }
        }
    }
}

//
//END EVENT HANDLER
//

}

// kate: space-indent off; tab-width 4; replace-tabs off;

---