WebSVN - Projects - Diff - Rev 475 and 476 - /MissionCockpit/branches/V0.2.0


#!/usr/bin/perl
#y!/usr/bin/perl -d:ptkdb
 
###############################################################################
#
# mkcockpit.pl -  MK Mission Cockpit - GUI
#
# Copyright (C) 2009  Rainer Walther  (rainerwalther-mail@web.de)
#
# Creative Commons Lizenz mit den Zusaetzen (by, nc, sa)
#
# Es ist Ihnen gestattet: 
#     * das Werk vervielfältigen, verbreiten und öffentlich zugänglich machen
#     * Abwandlungen bzw. Bearbeitungen des Inhaltes anfertigen
# 
# Zu den folgenden Bedingungen:
#     * Namensnennung.
#       Sie müssen den Namen des Autors/Rechteinhabers in der von ihm festgelegten Weise nennen.
#     * Keine kommerzielle Nutzung.
#       Dieses Werk darf nicht für kommerzielle Zwecke verwendet werden.
#     * Weitergabe unter gleichen Bedingungen.
#       Wenn Sie den lizenzierten Inhalt bearbeiten oder in anderer Weise umgestalten,
#       verändern oder als Grundlage für einen anderen Inhalt verwenden,
#       dürfen Sie den neu entstandenen Inhalt nur unter Verwendung von Lizenzbedingungen
#       weitergeben, die mit denen dieses Lizenzvertrages identisch oder vergleichbar sind.
# 
# Im Falle einer Verbreitung müssen Sie anderen die Lizenzbedingungen, unter welche dieses
# Werk fällt, mitteilen. Am Einfachsten ist es, einen Link auf diese Seite einzubinden.
# 
# Jede der vorgenannten Bedingungen kann aufgehoben werden, sofern Sie die Einwilligung
# des Rechteinhabers dazu erhalten.
# 
# Diese Lizenz lässt die Urheberpersönlichkeitsrechte unberührt.
# 
# Weitere Details zur Lizenzbestimmung gibt es hier:
#   Kurzform: http://creativecommons.org/licenses/by-nc-sa/3.0/de/
#   Komplett: http://creativecommons.org/licenses/by-nc-sa/3.0/de/legalcode
#
###############################################################################
# 2009-02-20 0.0.1 rw created
# 2009-04-01 0.1.0 rw RC1
# 2009-04-16 0.1.1 rw Bugfix, ALT= average of airsensor and Sat
# 2009-05-14 0.2.0 rw Waypoint Player
 
# 2009-05-25 0.2.1 rw Modified screen text to English by Mark Griffin
###############################################################################
 
$Version = "0.2.1 - 2009-05-25";
 
use threads;            # http://search.cpan.org/~jdhedden/threads-1.72/threads.pm
                        # http://perldoc.perl.org/threads.html
use threads::shared;    # http://search.cpan.org/~jdhedden/threads-shared-1.28/shared.pm
use Thread::Queue;      # http://search.cpan.org/dist/Thread-Queue-2.11/lib/Thread/Queue.pm
use Tk;
use Tk::Balloon;
use Tk::Dialog;
use Tk::Notebook;
use Math::Trig;
use Time::HiRes qw(usleep);  # http://search.cpan.org/~jhi/Time-HiRes-1.9719/HiRes.pm
use XML::Simple;             # http://search.cpan.org/dist/XML-Simple-2.18/lib/XML/Simple.pm
 
# change working directory to program path
my $Cwd = substr ($0, 0, rindex ($0, "mkcockpit.pl"));
chdir $Cwd;
 
# set path for local Perl libs
push @INC, $Cwd . "perl/lib", $Cwd . "perl/site/lib";
 
# Version setting
share (%Version);
$Version{'mkcockpit.pl'}  = $Version;
 
# Read configuration
 
$XmlConfigFile = "mkcockpit.xml";
$Cfg = XMLin($XmlConfigFile);
 
require "track.pl";     # Tracking antenna
require "mkcomm.pl";    # MK communication
require "logging.pl";   # CSV and GPX Logging
require "geserver.pl";  # Google Earth Server
require "$Cfg->{'map'}->{'MapDir'}/map.pl";   # Landkarte
require "libmap.pl";    # map subs
require "translate.pl"; # Übersetzungstable
 
# Thread fuer Kommunikation mit MK starten
# Output: %MkOsd, %MkTarget, %MkNcDebug, %Mk
# Input:  Thread-Queue: $MkSendQueue
$mk_thr = threads->create (\&MkCommLoop) -> detach();
 
# Start Logging Thread
$log_thr = threads->create (\&MkLogLoop) -> detach();
 
# Start GoogleEarth Thread
$ge_thr = threads->create (\&GeServer) -> detach();
 
# Aktuell gültige Karte
my %Map = %{$Maps{'Current'}};
       
# Hauptfenster
my $main = new MainWindow;
$main->title ("MK Mission Cockpit");
 
#-----------------------------------------------------------------
# Menu
#-----------------------------------------------------------------
 
# Menu bar
my $menu_bar = $main->Menu;
$main->optionAdd("*tearOff", "false");
$main->configure ('-menu' => $menu_bar);
 
my $menu_file = $menu_bar->cascade('-label' => "~File");
    $menu_file->command('-label' => 'Preferences',
                        '-command' => [\&Configure],
                       );
    $menu_file->separator;                                     
    $menu_file->command('-label' => 'E~xit',
                        '-command' => sub{exit(0)},
                        );
 
my $menu_debug = $menu_bar->cascade(-label => "D~ebug");
    $menu_debug->command('-label' => 'NC ~OSD Record (O)',
                         '-command' => [\&DisplayHash, \%MkOsd, "NC OSD Record (O)", "Display Refresh Heartbeat"],
                        );
    $menu_debug->command('-label' => 'NC ~Target Record (s)',
                         '-command' => [\&DisplayHash, \%MkTarget, "NC Target Record (s)", "Display Refresh Heartbeat"],
                        );
    $menu_debug->command('-label' => 'NC ~Debug Record (D)',
                         '-command' => [\&DisplayHash, \%MkNcDebug, "NC Debug Record (D)", "Display Refresh Heartbeat"],
                                        );             
    $menu_debug->command('-label' => 'NC ~Other',
                         '-command' => [\&DisplayHash, \%Mk, "NC Other", "Display Refresh Heartbeat"],
                                        );
    $menu_debug->separator;                                    
    $menu_debug->command('-label' => 'Tracking ~Antenna Debug Record',
                         '-command' => [\&DisplayHash, \%MkTrack, "Tracking Antenna Debug Record", "Display Refresh Heartbeat"],
                        );
 
my $menu_help = $menu_bar->cascade(-label => "~Help");
    $menu_help->command('-label' => 'Version',
                        '-command' => [\&DisplayHash, \%Version, "Version", "Display"],
                       );
    $menu_help->separator;
    $menu_help->command('-label' => 'About',
                        '-command' => sub
        {
        my $License = <<EOF;
Copyright (C) 2009  Rainer Walther (rainerwalther-mail\@web.de)
 
Creative Commons Lizenz mit den Zusaetzen (by, nc, sa)
 
Siehe LICENSE.TXT
EOF
 
        my $DlgAbout = $frame_map->Dialog('-title' => 'About MK Mission Cockpit',
                                          '-text' => "$License",
                                          '-buttons' => ['OK'],
                                          '-bitmap' => 'info',
                                         );
        $DlgAbout->Show;
        });  
 
 
# Main window Status line
$frame_status = $main->Frame( '-background' => 'lightgray',
                         ) -> pack('-side' => 'bottom',
                                   '-anchor' => 'w',
                                   '-fill' => 'none',
                                   '-expand' => 'y',
                                    );
$status_line = $frame_status->Label ('-text' => 'Status line',
                                    ) -> pack ('-side' => 'bottom',
                                               );
 
                                                                                           
#-----------------------------------------------------------------
# Frames
#-----------------------------------------------------------------                        
 
#
# Frame: Map
#
                                 
$frame_map = $main->Frame( '-background' => 'lightgray',
                           '-relief' => 'sunken',
                           '-borderwidth' => 5,
                          ) -> pack('-side' => 'top',
                                    '-fill' => 'x',
                                    );
 
# Map Überschrift
$frame_map_top = $frame_map->Frame() -> pack( '-side' => 'top',
                                              '-expand' => 'x',
                                              '-anchor' => 'w',
                                            );
 
$frame_map_top->Label ('-text' => "Karte: $Map{'Name'} ($Map{'File'})",
                       '-background' => 'lightgray',
                       '-relief' => 'flat',
                       ) -> pack( '-side' => 'left' );
 
# Map Statuszeile
$map_status = $frame_map->Frame( '-background' => 'lightgray',
                               ) -> pack('-side' => 'bottom',
                                         '-anchor' => 'w',
                                         '-fill' => 'none',
                                         '-expand' => 'y',
                                        );
$map_status_line = $map_status->Label ( '-text' => 'Statuszeile',
                                        '-background' => 'lightgray',
                                       ) -> pack ('-side' => 'bottom',);
 
# Map Canvas
 
# Canvas size
$MapSizeX  = $Map{'Size_X'};
$MapSizeY  = $Map{'Size_Y'};
 
$map_canvas = $frame_map->Canvas( '-width'  => $MapSizeX,
                                  '-height' => $MapSizeY,
                                  '-cursor' => 'cross',
                                ) -> pack();
 
# load Map photo
$map_canvas->Photo( 'Map',
                    '-file' => "$Cfg->{'map'}->{'MapDir'}/$Map{'File'}",
                  );
                                                               
$map_canvas->createImage( 0, 0,
                          '-tags' => 'Map',
                          '-anchor' => 'nw',
                          '-image'  => 'Map',
                        );             
 
# border polygon
$map_canvas->createPolygon( @Map{'Border'},
                           '-tags' => 'Map-Border',
                           '-fill' => '',
                           '-outline' => $Cfg->{'mkcockpit'}->{'ColorAirfield'}, '-width' => 2,
                          );
                           
# load Heartbeat icon
$map_canvas->Photo( 'HeartbeatSmall',
                    '-file' => "$Cfg->{'mkcockpit'}->{'IconHeartSmall'}",
                  );
$map_canvas->Photo( 'HeartbeatLarge',
                    '-file' => "$Cfg->{'mkcockpit'}->{'IconHeartLarge'}",
                  );
$map_canvas->createImage( $MapSizeX/4, 10,
                          '-tags' => 'Heartbeat',
                          '-anchor' => 'nw',
                          '-image'  => 'HeartbeatSmall',
                        );
 
# load Satellite icon
$map_canvas->Photo( 'Satellite-Photo',
                    '-file' => "$Cfg->{'mkcockpit'}->{'IconSatellite'}",
                               );
$map_canvas->createImage($MapSizeX-190, -100,   # hide photo 
                         '-tags' => 'Satellite',
                         '-anchor' => 'nw',
                         '-image'  => 'Satellite-Photo',
                        );
 
# load Waypoint icon
$map_canvas->Photo( 'Waypoint-Photo',
                    '-file' => "$Cfg->{'mkcockpit'}->{'IconWaypoint'}",
                  );
# load Target icon
$map_canvas->Photo( 'Target-Photo',
                    '-file' => "$Cfg->{'mkcockpit'}->{'IconTarget'}",
                  );
                                       
$map_canvas->createImage(0, -100,   # hide photo 
                         '-tags' => 'Target',
                         '-anchor' => 'nw',
                         '-image'  => 'Target-Photo',
                        );
 
# load Fox icon
$map_canvas->Photo( 'Fox-Photo',
                    '-file' => "$Cfg->{'mkcockpit'}->{'IconFox'}",
                  );
$map_canvas->createImage($MapSizeX/2+50, $MapSizeY/2,
                         '-tags' => 'Fox',
                         '-anchor' => 'nw',
                         '-image'  => 'Fox-Photo',
                        );
 
# load WP-Player icons
$map_canvas->Photo( 'WpPlay-Foto',  '-file' => "$Cfg->{'waypoint'}->{'IconPlay'}");
$map_canvas->Photo( 'WpStop-Foto',  '-file' => "$Cfg->{'waypoint'}->{'IconStop'}");
$map_canvas->Photo( 'WpPause-Foto', '-file' => "$Cfg->{'waypoint'}->{'IconPause'}");
$map_canvas->Photo( 'WpNext-Foto',  '-file' => "$Cfg->{'waypoint'}->{'IconNext'}");
$map_canvas->Photo( 'WpPrev-Foto',  '-file' => "$Cfg->{'waypoint'}->{'IconPrev'}");
$map_canvas->Photo( 'WpFirst-Foto', '-file' => "$Cfg->{'waypoint'}->{'IconFirst'}");
$map_canvas->Photo( 'WpLast-Foto',  '-file' => "$Cfg->{'waypoint'}->{'IconLast'}");
$map_canvas->Photo( 'WpHome-Foto',  '-file' => "$Cfg->{'waypoint'}->{'IconHome'}");
 
$map_canvas->createImage($MapSizeX/2+100, $MapSizeY-48,
                         '-tags' => 'Wp-PlayPause',
                         '-anchor' => 'nw',
                         '-image'  => 'WpPlay-Foto',
                        );
$map_canvas->createImage($MapSizeX/2+150, $MapSizeY-48,
                         '-tags' => 'Wp-Stop',
                         '-anchor' => 'nw',
                         '-image'  => 'WpStop-Foto',
                        );
$map_canvas->createImage($MapSizeX/2, $MapSizeY-48,
                         '-tags' => 'Wp-Next',
                         '-anchor' => 'nw',
                         '-image'  => 'WpNext-Foto',
                        );
$map_canvas->createImage($MapSizeX/2-50, $MapSizeY-48,
                         '-tags' => 'Wp-Prev',
                         '-anchor' => 'nw',
                         '-image'  => 'WpPrev-Foto',
                        );
$map_canvas->createImage($MapSizeX/2-100, $MapSizeY-48,
                         '-tags' => 'Wp-First',
                         '-anchor' => 'nw',
                         '-image'  => 'WpFirst-Foto',
                        );
$map_canvas->createImage($MapSizeX/2+50, $MapSizeY-48,
                         '-tags' => 'Wp-Last',
                         '-anchor' => 'nw',
                         '-image'  => 'WpLast-Foto',
                        );
$map_canvas->createImage($MapSizeX/2-150, $MapSizeY-48,
                         '-tags' => 'Wp-Home',
                         '-anchor' => 'nw',
                         '-image'  => 'WpHome-Foto',
                        );
 
 
# Balloon attached to Canvas
$map_balloon = $frame_map->Balloon('-statusbar' => $status_line, );
$map_balloon->attach($map_canvas,
                     '-balloonposition' => 'mouse',
                     '-state' => 'balloon',
                     '-msg' => { 'MK-Arrow' => "MikroKopter",
                                 'MK-Home-Line' => "Go Home",
                                 'MK-Home-Dist' => "Distance to Home",
                                 'MK-Target-Line' => "This way to the target",
                                 'MK-Target-Dist' => "Distance to target",
                                 'MK-Speed' => 'Velocity vector',
                                 'Map-Variometer' => 'Variometer',
                                 'Map-Variometer-Pointer' => 'Variometer',
                                 'Map-Variometer-Skala' => 'Variometer',
                                 'Fox' => 'Target for fox hunting',
                                 'Heartbeat' => 'MK data activity',
                                 'Satellite' => 'Good satellite reception',
                                 'Waypoint' => 'Waypoint',
                                 'Map-Border' => 'Map border',
                                 'Waypoint-Connector' => 'Waypoint Connector',
                                 'Wp-PlayPause' => 'Play/Pause',
                                 'Wp-Stop' => 'Stop',
                                 'Wp-First' => 'Go to First Waypoint',
                                 'Wp-Last' => 'Go to Last Waypoint',
                                 'Wp-Next' => 'Go to Next Waypoint',
                                 'Wp-Prev' => 'Go to Previous Waypoint',
                                 'Wp-Home' => 'Go Home',
                               },
                    );
#
# Mouse buttons
#
                                       
# general Mouse button 1
$map_canvas->CanvasBind("<Button-1>", sub
    {
    # print coords in status line
    my ($x, $y) = ($Tk::event->x, $Tk::event->y);
    my ($Lat, $Lon) = &MapXY2Gps($x, $y);
    $map_status_line->configure ('-text' => "Lat: $Lat  Lon: $Lon     x: $x  y: $y");
    });
       
# Mouse button 1 for Fox
my $FoxOldx = 0;
my $FoxOldy = 0;
 
# Pick Fox
$map_canvas->bind('Fox' => '<Button-1>' => sub
    {
    # prepare to move Fox
    my ($x, $y) = ($Tk::event->x, $Tk::event->y);
    $FoxOldx = $x;
    $FoxOldy = $y;
    $FoxTime = time;
    });
 
# Move Fox
$map_canvas->bind('Fox' => '<Button1-Motion>' => sub
    {
    my ($x, $y) = ($Tk::event->x, $Tk::event->y);
    my $id      = $map_canvas->find('withtag', 'current');
 
    $map_canvas->move($id => $x - $FoxOldx, $y - $FoxOldy);
    $FoxOldx = $x;
    $FoxOldy = $y;
       
    if ( time > $FoxTime )
        {
          # wenn in Bewegung Koordinaten nur 1/s senden
        my ($x0, $y0, $x1, $y1) = $map_canvas->bbox ($id);
        $x = $x0 + ($x1 - $x0)/2;
        $y = $y1;
 
        my ($Lat, $Lon) = &MapXY2Gps($x, $y);
        &MkFlyTo ( '-lat' => $Lat,
                   '-lon' => $Lon,
                   '-mode' => "Target",
                 );
        $FoxTime = time;
 
        $map_status_line->configure ('-text' => "Target coordinates sent -> Lat: $Lat  Lon: $Lon     x: $x  y: $y");
        }
    });
 
# Release Fox
$map_canvas->bind('Fox' => '<Button1-ButtonRelease>' => sub
    {
    my ($x, $y) = ($Tk::event->x, $Tk::event->y);
    my $id      = $map_canvas->find('withtag', 'current');
 
    my ($x0, $y0, $x1, $y1) = $map_canvas->bbox ($id);
    $x = $x0 + ($x1 - $x0)/2;
    $y = $y1;
       
    my ($Lat, $Lon) = &MapXY2Gps($x, $y);
    &MkFlyTo ( '-lat' => $Lat,
               '-lon' => $Lon,
               '-mode' => "Target",
             );
 
    # Show user that Waypoints in MK are cleared
    $WaypointsModified = 1;
    &WpRedrawLines();
 
    $map_status_line->configure ('-text' => "Target coordinates sent -> Lat: $Lat  Lon: $Lon     x: $x  y: $y");
    });
 
# Pick Waypoint
$map_canvas->bind('Waypoint' => '<Button-1>' => sub
    {
    # prepare to move
    my ($x, $y) = ($Tk::event->x, $Tk::event->y);
    $WpOldx = $x;
    $WpOldy = $y;
    });
       
# Move Waypoint
$map_canvas->bind('Waypoint' => '<Button1-Motion>' => sub
    {
    my ($x, $y) = ($Tk::event->x, $Tk::event->y);
    my $id      = $map_canvas->find('withtag', 'current');
 
    # move icon and Wp-Number
    my $WpIndex = &WpGetIndexFromId($id);
    if ( $WpIndex >= 0 )
        {
        my $Tag = $Waypoints[$WpIndex]{'Tag'};
        $map_canvas->move($Tag => $x - $WpOldx, $y - $WpOldy);
        }
 
    $WpOldx = $x;
    $WpOldy = $y;
    });
 
# Release Wp
$map_canvas->bind('Waypoint' => '<Button1-ButtonRelease>' => sub
    {
    my ($x, $y) = ($Tk::event->x, $Tk::event->y);
    my $id      = $map_canvas->find('withtag', 'current');
 
    # take coords from lower/middle icon position
    my ($x0, $y0, $x1, $y1) = $map_canvas->bbox ($id);
    $x = $x0 + ($x1 - $x0)/2;
    $y = $y1;
 
    # update Waypoint-Array
    my $WpIndex = &WpGetIndexFromId($id);
    if ( $WpIndex >= 0 )
            {
        # got it: set new coords
 
        my ($Lat, $Lon) = &MapXY2Gps($x, $y);
        my $Wp = $Waypoints[$WpIndex];
        $Wp->{'MapX'} = $x;
        $Wp->{'MapY'} = $y;
        $Wp->{'Pos_Lat'} = $Lat;
        $Wp->{'Pos_Lon'} = $Lon;
               
        # redraw connector-lines
        &WpRedrawLines();
 
        # red connectors: Wp still have to be sent to MK
        $map_canvas->itemconfigure('Waypoint-Connector',
                                       '-fill' => $Cfg->{'mkcockpit'}->{'ColorWpResend'},
                                      );
        $WaypointsModified = 1;
                       
        my $WpNum = $WpIndex + 1;
        $map_status_line->configure ('-text' => "Waypoint $WpNum postponed  Lat: $Lat  Lon: $Lon     x: $x  y: $y");
        }
    });
 
 
#
# Waypoint-Player - uses Waypoint-List: @Waypoints
#
 
# WP Player state machine
$WpPlayerMode = 'Stop';     # Start, Stop, Pause
$WpPlayerIndex = 0;
$WpPlayerHoldtime = -1;
 
# Mouse bindings
$map_canvas->bind('Wp-PlayPause' => '<Button-1>' => \&CbWpPlayerPlayPause );
$map_canvas->bind('Wp-Next'      => '<Button-1>' => \&CbWpPlayerNext );
$map_canvas->bind('Wp-Prev'      => '<Button-1>' => \&CbWpPlayerPrev );
$map_canvas->bind('Wp-First'     => '<Button-1>' => \&CbWpPlayerFirst );
$map_canvas->bind('Wp-Last'      => '<Button-1>' => \&CbWpPlayerLast );
$map_canvas->bind('Wp-Home'      => '<Button-1>' => \&CbWpPlayerHome );
$map_canvas->bind('Wp-Stop'      => '<Button-1>' => \&CbWpPlayerStop );
 
 
# Focus Canvas, if any key pressed. Needed for the following key-bindings
$main->bind('<Any-Enter>' => sub { $map_canvas->Tk::focus });
 
# Disable default bindings on canvas
$main->bind('Tk::Canvas',"<$_>",undef)for qw /Left Right Up Down/;
 
# keyboard bindings
$map_canvas->Tk::bind( '<Key-space>', \&CbWpPlayerPlayPause );
$map_canvas->Tk::bind( '<Key-n>'    , \&CbWpPlayerNext );
$map_canvas->Tk::bind( '<Key-p>'    , \&CbWpPlayerPrev );
$map_canvas->Tk::bind( '<Key-f>'    , \&CbWpPlayerFirst );
$map_canvas->Tk::bind( '<Key-l>'    , \&CbWpPlayerLast );
$map_canvas->Tk::bind( '<Key-h>'    , \&CbWpPlayerHome );
$map_canvas->Tk::bind( '<Key-s>'    , \&CbWpPlayerStop );
 
 
# Mouse button 3 context menu
my $map_menu = $map_canvas->Menu('-tearoff' => 0,
                                 '-title' =>'None',
                                 '-menuitems' =>
    [
     [Button => "Add Waypoint and send",  -command => sub
        {
        my $Tag = sprintf "Waypoint-%d.%d", time, int (rand(9)) ;   # kind of unique Tag for this Wp
 
        # Waypoint Icon
        my $IconHeight = 48;
        my $IconWidth = 48;
        $map_canvas->createImage($MapCanvasX-$IconWidth/2, $MapCanvasY-$IconHeight,
                                 '-tags' => ['Waypoint', $Tag],
                                 '-anchor' => 'nw',
                                 '-image'  => 'Waypoint-Photo',
                                );
 
        # Waypoint Number
        my $WpNumber = scalar @Waypoints + 1;
        $map_canvas->createText ( $MapCanvasX+3, $MapCanvasY-$IconHeight/2+12,
                                  '-tags' => ['WaypointNumber', $Tag],
                                  '-text' => $WpNumber,
                                  '-font' => '-*-Arial-Bold-R-Normal--*-100-*',
                                  '-fill' => $Cfg->{'mkcockpit'}->{'ColorWpNumber'},
                                  '-anchor' => 'w',
                                 );    
 
        $map_canvas->lower('Waypoint', 'Fox');            # waypoint below Fox
        $map_canvas->lower('WaypointNumber', 'Waypoint'); # Nr below waypoint
 
        # send Wp to MK         
        ($Lat, $Lon) = &MapXY2Gps($MapCanvasX, $MapCanvasY);
        &MkFlyTo ( '-lat' => $Lat,
                   '-lon' => $Lon,
                   '-mode' => "Waypoint"
                 );
       
        # save Wp-Hash in Waypoint-Array
        my $Wp = {};        
        $Wp->{'Tag'} = $Tag;
        $Wp->{'MapX'} = $MapCanvasX;
        $Wp->{'MapY'} = $MapCanvasY;
        $Wp->{'Pos_Lat'} = $Lat;
        $Wp->{'Pos_Lon'} = $Lon;
        $Wp->{'Pos_Alt'} = $MkOsd{'CurPos_Alt'};
        $Wp->{'Heading'}         = $Cfg->{'waypoint'}->{'DefaultHeading'};
        $Wp->{'ToleranceRadius'} = $Cfg->{'waypoint'}->{'DefaultToleranceRadius'};
        $Wp->{'Holdtime'}        = $Cfg->{'waypoint'}->{'DefaultHoldtime'};
        $Wp->{'Event_Flag'}      = $Cfg->{'waypoint'}->{'DefaultEventFlag'};
        push @Waypoints, $Wp;
 
        # redraw connector-lines
        &WpRedrawLines();  
 
        $map_status_line->configure ('-text' => "Waypoint is stored and sent -> Lat: $Lat Lon: $Lon");
        }],
 
 
     [Button => "Waypoint Properties",  -command => sub
        {
        # find Wp-Hash for selected icon/tag
        my $WpIndex = &WpGetIndexFromId($MapCanvasId);
        if ( $WpIndex >= 0 )
            {
            my $Wp = $Waypoints[$WpIndex];
            my $WpNum = $WpIndex + 1;
 
            &DisplayHash ($Wp, "Waypoint Properties $WpNum", "Edit Waypoint Refresh");
 
            $map_status_line->configure ('-text' => "Wegpunkt $WpNum Eigenschaften");
            }
        }],
               
     [Button => " Send all Waypoints again",  -command => sub
        {
        &WpSendAll();
               
        $map_status_line->configure ('-text' => "All waypoints sent");
        }],
 
      '',   # Separator
       
     [Button => "Waypoint loaded and sent",  -command => sub
        {
        $WpFile = $main->getOpenFile('-defaultextension' => ".xml",
                                     '-filetypes'        =>
                                         [['Waypoints',     '.xml' ],
                                          ['All Files',     '*', ],
                                         ],
                                     '-initialdir' => $Cfg->{'waypoint'}->{'WpDir'},
                                     '-title' => "Wegpunkte laden",
                                    );
        if ( -f $WpFile )
            {
            # XML in Hash-Ref lesen
            my $Wp = XMLin($WpFile, ForceArray => 1);
 
            # XML Hash-Ref in Wp-Array umkopieren
            undef @Waypoints;
            foreach $key (sort keys %$Wp)
                {
                my $Point = $Wp->{$key}->[0];
 
                # relative Pixelkoordinaten auf Bildgroesse umrechnen
                if ( $Point->{'MapX'} <= 1  and  $Point->{'MapY'} <= 1 )
                    {
                    $Point->{'MapX'} = int ( $Point->{'MapX'} * $MapSizeX + 0.5 );
                    $Point->{'MapY'} = int ( $Point->{'MapY'} * $MapSizeY + 0.5 );
                    }
 
                # GPS Koordinaten für die aktuelle Karte neu aus Map x/y berechnen
                my ($Lat, $Lon) = &MapXY2Gps($Point->{'MapX'}, $Point->{'MapY'});
                $Point->{'Pos_Lat'} = $Lat;
                $Point->{'Pos_Lon'} = $Lon;
 
                push @Waypoints, $Point;
                }
 
            &WpSendAll();
            &WpRedrawLines();
            &WpRedrawIcons();
       
            $map_status_line->configure ('-text' => "Waypoints from $WpFile loaded and sent");
            }
        }],    
       
     [Button => "Save Waypoints",  -command => sub
        {
        $WpFile = $main->getSaveFile('-defaultextension' => ".xml",
                                     '-filetypes'        =>
                                       [['Waypoints',     '.xml' ],
                                        ['All Files',     '*', ],
                                       ],
                                     '-initialdir' => $Cfg->{'waypoint'}->{'WpDir'},
                                     '-title' => "Save Waypoints",
                                    );
 
        # Waypoint-Array in Hash umkopieren
        my %Wp;
        for  $i ( 0 .. $#Waypoints )
            {
 
            my $key = sprintf ("WP-%04d", $i);
            $Wp{$key} = $Waypoints[$i];
 
            # Pixelkoordinaten relativ zur Bildgroesse speichern
            $Wp{$key}{'MapX'} /= $MapSizeX;
            $Wp{$key}{'MapY'} /= $MapSizeY;
            }
 
        # WP-Hash als XML speichern
        &XMLout (\%Wp,
                 'OutputFile' => $WpFile,
                 'AttrIndent' => '1',
                 'RootName' => 'Waypoints',
                );
               
        $map_status_line->configure ('-text' => "Waypoints stored in $WpFile");
        }],
               
     '',   # Separator
 
     [Button => "Delete waypoint",  -command => sub
        {
        # find Wp-Hash for selected icon/tag
        my $WpIndex = &WpGetIndexFromId($MapCanvasId);
        if ( $WpIndex >= 0 )
            {
            my $Wp = $Waypoints[$WpIndex];
 
            # remove icon and Wp-Number on canvas;
            $map_canvas->delete($Wp->{'Tag'});
 
            # delete Wp in Waypoint-Array
            splice @Waypoints, $WpIndex, 1;
 
            # redraw connector-lines
            $WaypointsModified = 1;
            &WpRedrawLines();  
            &WpRedrawIcons();  # wg. Wp-Nummern
 
            $WpNum = $WpIndex + 1;
            $map_status_line->configure ('-text' => "Waypoint $WpNum deleted");
            }
        }],
 
     [Button => "Delete all waypoints and send",  -command => sub
        {
        undef @Waypoints;
 
        # remove all Wp-Icons and Wp-Number on canvas
        $map_canvas->delete('Waypoint');
        $map_canvas->delete('WaypointNumber');
               
        # redraw connector-lines
        &WpRedrawLines();  
 
        &WpSendAll();
 
        $map_status_line->configure ('-text' => "All Waypoints $WpIndex deleted");
        }],
 
    '',   # Separator
         
     [Button => "Fly immediately to Target",  -command => sub
        {
        &MkFlyTo ( '-x' => $MapCanvasX,
                   '-y' => $MapCanvasY,
                   '-mode' => "Target"
                 );
 
        # redraw connector-lines
        $WaypointsModified = 1;
        &WpRedrawLines();  
 
        $map_status_line->configure ('-text' => "Target coordinates sent -> Lat: $Lat  Lon: $Lon     x: $x  y: $y");
        }],
    ]
                                    );
$map_canvas->CanvasBind("<Button-3>" => [ sub
    {
    $map_canvas->focus;
    my($w, $x, $y) = @_;
    ($MapCanvasX, $MapCanvasY) = ($Tk::event->x, $Tk::event->y);
    $MapCanvasId = $map_canvas->find('withtag', 'current');
    $map_menu->post($x, $y);
    }, Ev('X'), Ev('Y') ] );
 
 
#
# Objects on canvas
#
 
# Line from MK to Home
$map_canvas->createLine ( $MapSizeX/2, $MapSizeY/2, $MapSizeX/2, $MapSizeY/2,
                          '-tags' => 'MK-Home-Line',
                          '-arrow' => 'none',
                          '-fill' => $Cfg->{'mkcockpit'}->{'ColorHomeLine'},
                          '-width' => 3,
                         );
                                                                                 
# Text Entfernung positioniert an der Home-Linie
$map_canvas->createText ( $MapSizeX/2 + 8, $MapSizeY/2 - 8,
                          '-tags' => 'MK-Home-Dist',
                          '-text' => '0 m',
                          '-anchor' => 'w',
                          '-font' => '-*-Arial-Bold-R-Normal--*-200-*',
                          '-fill' => $Cfg->{'mkcockpit'}->{'ColorHomeDist'},
                          );
 
# Line from MK to Target, draw invisible out of sight
$map_canvas->createLine ( 0, -100, 0, -100,
                          '-tags' => 'MK-Target-Line',
                          '-arrow' => 'none',
                          '-fill' => $Cfg->{'mkcockpit'}->{'ColorTargetLine'},
                          '-width' => 3,
                         );
                                                                                 
# Text Entfernung positioniert an der Target-Linie
$map_canvas->createText ( 0, -100,
                          '-tags' => 'MK-Target-Dist',
                          '-text' => '0 m',
                          '-anchor' => 'w',
                          '-font' => '-*-Arial-Bold-R-Normal--*-200-*',
                          '-fill' => $Cfg->{'mkcockpit'}->{'ColorTargetDist'},
                          );
                                                 
# MK Geschwindigkeits-Vektor
$MapMkSpeedLen = 60;    # Länge Speed-Zeiger
my $x0 = $MapSizeX/2;
my $y0 = $MapSizeY/2;
my $x1 = $MapSizeX/2;
my $y1 = $MapSizeY/2 - $MapMkSpeedLen;
$map_canvas->createLine ( $x0, $y0, $x1, $y1,
                          '-tags' => 'MK-Speed',
                          '-arrow' => 'last',
                          '-arrowshape' => [10, 10, 3 ],
                          '-fill' => $Cfg->{'mkcockpit'}->{'ColorSpeedVector'},
                          '-width' => 4,
                         );
 
# MK als Pfeilspitze einer Linie darstellen
$MapMkLen = 25;
my $x0 = $MapSizeX/2;
my $y0 = $MapSizeY/2 + $MapMkLen/2;
my $x1 = $MapSizeX/2;
my $y1 = $MapSizeY/2 - $MapMkLen/2;
$map_canvas->createLine ( $x0, $y0, $x1, $y1,
                          '-tags' => 'MK-Arrow',
                          '-arrow' => 'last',
                          '-arrowshape' => [25, 30, 10 ],
                          '-fill' => $Cfg->{'mkcockpit'}->{'ColorMkSatNo'},
                          '-width' => 1
                         );
 
                                                 
# OSD Daten auf Karte anzeigen
 
# Flugzeit
$map_canvas->createText ( $MapSizeX/2 - 40, 20,
                          '-tags' => 'MK-OSD-Tim-Label',
                          '-text' => 'TIM',
                          '-font' => '-*-Arial-Bold-R-Normal--*-150-*',
                          '-fill' => $Cfg->{'mkcockpit'}->{'ColorOsd'},
                          '-anchor' => 'w',
                         );
 
$map_canvas->createText ( $MapSizeX/2, 20,
                          '-tags' => 'MK-OSD-Tim-Value',
                          '-text' => $MkFlyingTime,            # $MkOsd{'FlyingTime'},
                          '-font' => '-*-Arial-Bold-R-Normal--*-270-*',
                          '-fill' => $Cfg->{'mkcockpit'}->{'ColorOsd'},
                          '-anchor' => 'w',
                         );
 
# Batterie Spannung
$map_canvas->createText ( $MapSizeX/2 - 40, 50,
                          '-tags' => 'MK-OSD-Bat-Label',
                          '-text' => 'BAT',
                          '-font' => '-*-Arial-Bold-R-Normal--*-150-*',
                          '-fill' => $Cfg->{'mkcockpit'}->{'ColorOsd'},
                          '-anchor' => 'w',
                         );
 
$map_canvas->createText ( $MapSizeX/2, 50,
                          '-tags' => 'MK-OSD-Bat-Value',
                          '-text' => sprintf ("%3.1f V", $MkOsd{'UBat'}),
                          '-font' => '-*-Arial-Bold-R-Normal--*-270-*',
                          '-fill' => $Cfg->{'mkcockpit'}->{'ColorOsd'},
                          '-anchor' => 'w',
                         );
 
# Ground speed
$map_canvas->createText ( 10,  20,
                          '-tags' => 'MK-OSD-Spd-Label',
                          '-text' => 'SPD',
                          '-font' => '-*-Arial-Bold-R-Normal--*-150-*',
                          '-fill' => $Cfg->{'mkcockpit'}->{'ColorOsd'},
                          '-anchor' => 'w',
                         );
 
$map_canvas->createText ( 50,  20,
                          '-tags' => 'MK-OSD-Spd-Value',
                          '-text' => sprintf ("%3d km/h", $MkOsd{'GroundSpeed'} * 0.036),
                          '-font' => '-*-Arial-Bold-R-Normal--*-270-*',
                          '-fill' => $Cfg->{'mkcockpit'}->{'ColorOsd'},
                          '-anchor' => 'w',
                         );
 
# Hoehe (Luftdruck)
$map_canvas->createText ( 10,  50,
                          '-tags' => 'MK-OSD-Alt-Label',
                          '-text' => 'ALT',
                          '-font' => '-*-Arial-Bold-R-Normal--*-150-*',
                          '-fill' => $Cfg->{'mkcockpit'}->{'ColorOsd'},
                          '-anchor' => 'w',
                         );
 
$map_canvas->createText ( 50,  50,
                          '-tags' => 'MK-OSD-Alt-Value',
                          '-text' => sprintf ("%3d m", $MkOsd{'Altimeter'}/$Cfg->{'mkcockpit'}->{'AltFactor'}),
                          '-font' => '-*-Arial-Bold-R-Normal--*-270-*',
                          '-fill' => $Cfg->{'mkcockpit'}->{'ColorOsd'},
                          '-anchor' => 'w',
                         );
 
# Variometer 
$map_canvas->createText ( 10,  80,
                          '-tags' => 'MK-OSD-Vsi-Label',
                          '-text' => 'VSI',
                          '-font' => '-*-Arial-Bold-R-Normal--*-150-*',
                          '-fill' => $Cfg->{'mkcockpit'}->{'ColorOsd'},
                          '-anchor' => 'w',
                         );
 
$map_canvas->createText ( 50,  80,
                          '-tags' => 'MK-OSD-Vsi-Value',
                          '-text' => sprintf ("%3d", $MkOsd{'Variometer'}),
                          '-font' => '-*-Arial-Bold-R-Normal--*-270-*',
                          '-fill' => $Cfg->{'mkcockpit'}->{'ColorOsd'},
                          '-anchor' => 'w',
                         );
 
# Anzahl Satelitten
$map_canvas->createText ( $MapSizeX - 130, 20,
                          '-tags' => 'MK-OSD-Sat-Label',
                          '-text' => 'SAT',
                          '-font' => '-*-Arial-Bold-R-Normal--*-150-*',
                          '-fill' => $Cfg->{'mkcockpit'}->{'ColorOsd'},
                          '-anchor' => 'w',
                         );
 
$map_canvas->createText ( $MapSizeX - 80, 20,
                          '-tags' => 'MK-OSD-Sat-Value',
                          '-text' => "$MkOsd{'SatsInUse'}",
                          '-font' => '-*-Arial-Bold-R-Normal--*-270-*',
                          '-fill' => $Cfg->{'mkcockpit'}->{'ColorOsd'},
                          '-anchor' => 'w',
                         );
 
# Wegpunkte
$map_canvas->createText ( $MapSizeX - 130, 50,
                          '-tags' => 'MK-OSD-Wp-Label',
                          '-text' => 'WPT',
                          '-font' => '-*-Arial-Bold-R-Normal--*-150-*',
                          '-fill' => $Cfg->{'mkcockpit'}->{'ColorOsd'},
                          '-anchor' => 'w',
                         );
 
$map_canvas->createText ( $MapSizeX - 80, 50,
                          '-tags' => 'MK-OSD-Wp-Value',
                          '-text' => $MkOsd{'WaypointIndex'} . "/" . $MkOsd{'WaypointNumber'} ,
                          '-font' => '-*-Arial-Bold-R-Normal--*-270-*',
                          '-fill' => $Cfg->{'mkcockpit'}->{'ColorOsd'},
                          '-anchor' => 'w',
                         );
# Navigation Mode
$map_canvas->createText ( $MapSizeX - 130, 80,
                          '-tags' => 'MK-OSD-Mode-Label',
                          '-text' => 'MOD',
                          '-font' => '-*-Arial-Bold-R-Normal--*-150-*',
                          '-fill' => $Cfg->{'mkcockpit'}->{'ColorOsd'},
                          '-anchor' => 'w',
                         );
 
$map_canvas->createText ( $MapSizeX - 80, 80,
                          '-tags' => 'MK-OSD-Mode-Value',
                          '-text' => '' ,
                          '-font' => '-*-Arial-Bold-R-Normal--*-270-*',
                          '-fill' => $Cfg->{'mkcockpit'}->{'ColorOsd'},
                          '-anchor' => 'w',
                         );
                       
# Waypoint Holdtime count down
$map_canvas->createText ( $MapSizeX - 130, -110,
                          '-tags' => 'MK-OSD-Holdtime-Label',
                          '-text' => 'HLD',                             # Holdtime Count Down
                          '-font' => '-*-Arial-Bold-R-Normal--*-150-*',
                          '-fill' => $Cfg->{'mkcockpit'}->{'ColorOsd'},
                          '-anchor' => 'w',
                         );
 
$map_canvas->createText ( $MapSizeX - 80, -110,
                          '-tags' => 'MK-OSD-Holdtime-Value',
                          '-text' => '--' ,
                          '-font' => '-*-Arial-Bold-R-Normal--*-270-*',
                          '-fill' => $Cfg->{'mkcockpit'}->{'ColorOsd'},
                          '-anchor' => 'w',
                         );                      
 
# Variometer on canvas
my @Polygon;
for ( $y = -100; $y <= 100; $y += 10)
    {
    my $Len = 5;
    if ( ($y % 50) == 0 )
        {
        $Len = 10;
        $map_canvas->createText ( $Len+5, $MapSizeY/2 + $y,
                                  '-tags' => 'Map-Variometer-Skala',
                                  '-text' => sprintf ("%3d", -$y / 10),
                                  '-anchor' => 'w',
                                  '-font' => '-*-Arial-Normal-R-Normal--*-150-*',
                          '-fill' => $Cfg->{'mkcockpit'}->{'ColorVariometer'},
                          );
        }
    push @Polygon, (   0, $MapSizeY/2 + $y);
    push @Polygon, ($Len, $MapSizeY/2 + $y);
    push @Polygon, (   0, $MapSizeY/2 + $y);
    }
 
$map_canvas->createLine(@Polygon,
                        '-tags' => 'Map-Variometer',
                        '-fill' => $Cfg->{'mkcockpit'}->{'ColorVariometer'},
                        '-width' => 2,
                        '-arrow' => 'none',
                       );
# Vario Pointer
$map_canvas->createPolygon( 5, $MapSizeY/2, 20, $MapSizeY/2+10, 20, $MapSizeY/2-10,
                           '-tags' => 'Map-Variometer-Pointer',
                           '-fill' => $Cfg->{'mkcockpit'}->{'ColorVariometerPointer'},
                           '-outline' => 'black', '-width' => 1,
                          );
 
# Tracking Canvas
 
if ( $Cfg->{'track'}->{'Active'} =~ /y/i )
    {
    # Canvas size
    $TrackSizeX  = 125;
    $TrackSizeY  = 100;
    $TrackOffY   = $TrackSizeY - $MapSizeY + 20;
    $TrackPtrLen = 50;    # Länge Zeiger
 
    # draw in map-canvas
    $track_canvas = $map_canvas;
 
    # Ziffernblatt
    my $x0 = $TrackSizeX/2 - $TrackPtrLen;
    my $y0 = $TrackSizeY + $TrackPtrLen - $TrackOffY;
    my $x1 = $TrackSizeX/2 + $TrackPtrLen;
    my $y1 = $TrackSizeY   - $TrackPtrLen - $TrackOffY;
    $track_canvas->createArc ( $x0, $y0, $x1, $y1,
                               '-extent' => '200',
                               '-start' => '-10',
                               '-style' => 'chord',
                               '-outline' => 'gray', '-width' => '1',
                             );
 
    # Skala Ziffernblatt
    for ($i=0; $i<=180; $i+=15)
        {
        my $pi = 3.14159265358979;
        my $x0 = $TrackSizeX/2 - ($TrackPtrLen - 20) * cos($i / 180 * $pi);
        my $y0 = $TrackSizeY   - ($TrackPtrLen - 20) * sin($i / 180 * $pi) - $TrackOffY;
        my $x1 = $TrackSizeX/2 - ($TrackPtrLen - 28) * cos($i / 180 * $pi);
        my $y1 = $TrackSizeY   - ($TrackPtrLen - 28) * sin($i / 180 * $pi) - $TrackOffY;
        $track_canvas->createLine ( $x0, $y0, $x1, $y1,
                                   '-fill' => 'white',
                                   '-width' => 1,
                                  );
        }
 
    # Skala Beschriftung Ziffernblatt
    for ($i=0; $i<=180; $i+=45)
        {
        my $pi = 3.14159265358979;
        my $x0 = $TrackSizeX/2 - ($TrackPtrLen - 12) * cos($i / 180 * $pi);
        my $y0 = $TrackSizeY   - ($TrackPtrLen - 12) * sin($i / 180 * $pi) - $TrackOffY;
        $track_canvas->createText ( $x0, $y0,
                                   '-text' => $i - 90,
                                   '-fill' => 'white',
                                  );
        }
 
    # Ziffernblatt Beschriftung Einheit
    my $x0 = $TrackSizeX/2;
    my $y0 = $MapSizeY -6;
    $track_canvas->createText ( $x0, $y0,
                                '-text' => "Antenna Angle",
                                '-justify' => 'center',
                                '-fill' => 'white',
                                );
                                         
    # Zeiger
    my $x0 = $TrackSizeX/2;
    my $y0 = $TrackSizeY - 0 - $TrackOffY;
    my $x1 = $TrackSizeX/2;
    my $y1 = $TrackSizeY - ($TrackPtrLen - 22) - $TrackOffY;
    $track_ptr_id= $track_canvas->createLine ( $x0, $y0, $x1, $y1,
                                               '-tags' => 'Track-Ptr',
                                               '-arrow' => 'last',
                                               '-arrowshape' => [20, 30, 5 ],
                                               '-fill' => 'red',
                                               '-width' => 8,
                                              );
    # Zeiger Center
    my $Dia = 7;
    my $x0 = $TrackSizeX/2 - $Dia;
    my $y0 = $TrackSizeY + $Dia - $TrackOffY;
    my $x1 = $TrackSizeX/2 + $Dia;
    my $y1 = $TrackSizeY   - $Dia - $TrackOffY;
    $track_canvas->createArc ( $x0, $y0, $x1, $y1,
                               '-extent' => '359',
                               '-outline' => 'gray', '-width' => 1,
                               '-fill' => 'gray',
                             );
    }
                                                                                 
#-----------------------------------------------------------------
# Timer
#-----------------------------------------------------------------                        
 
#
# Timer: 5s
#
$main->repeat (5000, sub
    {
    if ( ! $MkSendWp )
        {
        # Query Frequency OSD und Debug regelmäßig neu einstellen, falls Übertragungsfehler
        $MkSendQueue->enqueue( "o", "$AddrNC", pack ("C", 10) );   # Frequency OSD Record, * 10ms
        $MkSendQueue->enqueue( "d", "$AddrNC", pack ("C", 10) );   # Frequency MK Debug Record, * 10ms
        $MkSendQueue->enqueue( "v", "$AddrNC", "");   # Version
        $MkSendQueue->enqueue( "e", "$AddrNC", "");   # Error Text Request
        }
    });
 
#       
# Timer: 0.1s - Map Overlay aktualisieren
#
$frame_map_top->repeat (100, sub
    {
    lock (%MkOsd);              # until end of block
 
    # Aktuell gültige Karte
    my %Map = %{$Maps{'Current'}};
 
    if ( $MkOsd{'_Timestamp'} >= time-2 )
        {
        # Gueltige OSD Daten
        my $SatsInUse = $MkOsd{'SatsInUse'};
        if ( $SatsInUse > 0  and  $MkOsd{'CurPos_Stat'} == 1 and $MkOsd{'HomePos_Stat'} == 1 )
            {
            # ausreichender GPS Empfang
 
            # get x,y map coords of current position
            my ($C_x, $C_y, $C_Angel) = &MapGps2XY($MkOsd{'CurPos_Lat'}, $MkOsd{'CurPos_Lon'}, $MkOsd{'CompassHeading'});
               
            # rotate MK arrow
            my $dy = sin (deg2rad $C_Angel) * ($MapMkLen/2);
            my $dx = cos (deg2rad $C_Angel) * ($MapMkLen/2);
            my $x0 = $C_x - $dx;
            my $y0 = $C_y - $dy;
            my $x1 = $C_x + $dx;
            my $y1 = $C_y + $dy;
            $map_canvas->coords ('MK-Arrow', $x0, $y0, $x1, $y1);
 
            # Update speed vector
            my $MapAngel = &MapAngel();   # Norh to Map-Horizont
            my $GpsSpeedNorth = $MkNcDebug{'Analog_21'};
            my $GpsSpeedEast  = $MkNcDebug{'Analog_22'};
            my $PhiGpsSpeed = rad2deg atan2 ( $GpsSpeedEast, $GpsSpeedNorth );
            $PhiMapSpeed = $PhiGpsSpeed - $MapAngel;
 
            # 555 cm/s ~ 20 km/h -> Zeigerlänge = $MkSpeedLen bei 20 km/h
            my $dy = sin (deg2rad $PhiMapSpeed) * $MapMkSpeedLen * $MkOsd{'GroundSpeed'} / 555;
            my $dx = cos (deg2rad $PhiMapSpeed) * $MapMkSpeedLen * $MkOsd{'GroundSpeed'} / 555;
            my $x0 = $C_x;
            my $y0 = $C_y;
            my $x1 = $C_x + $dx;
            my $y1 = $C_y + $dy;
            $map_canvas->coords ('MK-Speed', $x0, $y0, $x1, $y1);
 
            # Update Line between Home and MK
            my ($H_x, $H_y) = &MapGps2XY($MkOsd{'HomePos_Lat'}, $MkOsd{'HomePos_Lon'});
            $map_canvas->coords ('MK-Home-Line', $H_x, $H_y, $C_x, $C_y);
 
            # Update Distance between Home and MK
            my ($Dist, $Bearing) = MapGpsTo($MkOsd{'CurPos_Lat'}, $MkOsd{'CurPos_Lon'},
                                                   $MkOsd{'HomePos_Lat'}, $MkOsd{'HomePos_Lon'} );
            my $x = ($C_x - $H_x) / 2 + $H_x + 8;
            my $y = ($C_y - $H_y) / 2 + $H_y + 8;
            $map_canvas->coords ('MK-Home-Dist', $x, $y);
            $map_canvas->itemconfigure ('MK-Home-Dist',
                                        '-text' => sprintf ("%4d m", $Dist),
                                       );
 
            # Update OSD - Sat dependent values
            $map_canvas->itemconfigure ('MK-OSD-Spd-Value', '-text' => sprintf ("%3d km/h", $MkOsd{'GroundSpeed'} * 0.036) );
 
            # Alt = average Luftdruck und Sat
            my $Alt = int ( ($MkOsd{'Altimeter'} / $Cfg->{'mkcockpit'}->{'AltFactor'} +
                             $MkOsd{'CurPos_Alt'} - $MkOsd{'HomePos_Alt'} + 0.5) / 2 );
            $map_canvas->itemconfigure ('MK-OSD-Alt-Value', '-text' => sprintf ("%d m", $Alt) );
 
            if ( $MkOsd{'TargetPos_Stat'} == 1 )
                {
                # Valid Target
                # Update Line between Target and MK
                my ($T_x, $T_y) = &MapGps2XY($MkOsd{'TargetPos_Lat'}, $MkOsd{'TargetPos_Lon'});
                $map_canvas->coords ('MK-Target-Line', $C_x, $C_y, $T_x, $T_y);
 
                # Update Distance between Target and MK
                my ($Dist, $Bearing) = MapGpsTo($MkOsd{'CurPos_Lat'}, $MkOsd{'CurPos_Lon'},
                                                        $MkOsd{'TargetPos_Lat'}, $MkOsd{'TargetPos_Lon'} );
                my $x = ($C_x - $T_x) / 2 + $T_x - 8;
                my $y = ($C_y - $T_y) / 2 + $T_y + 8;
                $map_canvas->coords ('MK-Target-Dist', $x, $y);
                $map_canvas->itemconfigure ('MK-Target-Dist',
                                            '-text' => sprintf ("%4d m", $Dist),
                                           );
                # show target icon
                my $IconHeight = 48;
                my $IconWidth = 48;
                $map_canvas->coords('Target', $T_x - $IconWidth/2, $T_y - $IconHeight );
                }
            else
                {
                # No valid Target, move target line out of sight/canvas
                $map_canvas->coords ('MK-Target-Line', 0, -100, 0, -100);
                $map_canvas->coords ('MK-Home-Dist', 0, -100);
 
                # hide target icon
                $map_canvas->coords('Target', 0, -100, );
                }
            }
        else
            {
            # kein ausreichender Sat-Empfang
            $map_canvas->itemconfigure ('MK-OSD-Spd-Value', '-text' => sprintf ("%3d km/h", 0 ) );
            }
 
        # Update OSD - non Sat dependent values
        $map_canvas->itemconfigure ('MK-OSD-Bat-Value', '-text' => sprintf ("%3.1f V", $MkOsd{'UBat'}) );
        $map_canvas->itemconfigure ('MK-OSD-Vsi-Value', '-text' => sprintf ("%3d", $MkOsd{'Variometer'}) );
        $map_canvas->itemconfigure ('MK-OSD-Tim-Value', '-text' => sprintf ("%02d:%02d", $MkFlyingTime / 60, $MkFlyingTime % 60) );
        $map_canvas->itemconfigure ('MK-OSD-Sat-Value', '-text' => $MkOsd{'SatsInUse'} );
 
        # Waypoints abhaengig vom Modus NC/Player
        my $WpValue = "--/--";
        if ( $MkOsd{'WaypointNumber'} > 0)
            {
            $WpValue = sprintf ("%d/%d", $MkOsd{'WaypointIndex'} +1, $MkOsd{'WaypointNumber'});
            }
        if ($WpPlayerMode ne "Stop")
            {
            $WpValue = sprintf ("%d/%d", $WpPlayerIndex +1, scalar @Waypoints);
            }
        $map_canvas->itemconfigure ('MK-OSD-Wp-Value',  '-text' => "$WpValue");
 
        # blink battery warning
        $map_canvas->itemconfigure ('MK-OSD-Bat-Value', '-fill' => $Cfg->{'mkcockpit'}->{'ColorOsd'});
        if ( $MkOsd{'UBat'}  <  $Cfg->{'mkcockpit'}->{'UBatWarning'} )
            {
            if ( time %2 )
                {
                $map_canvas->itemconfigure ('MK-OSD-Bat-Value', '-fill' => 'red');
                }
            }
 
        my $Mode = "";
        if ($MkOsd{'NCFlags'} & 0x04) { $Mode = "WPT"};
        if ($WpPlayerMode eq "Play")  { $Mode = "Play" };
        if ($WpPlayerMode eq "Pause") { $Mode = "Paus" };
        if ($WpPlayerMode eq "Home")  { $Mode = "Home" };
        if ($MkOsd{'NCFlags'} & 0x01) { $Mode = "Free"};
        if ($MkOsd{'NCFlags'} & 0x02) { $Mode = "PH"};
        if ($MkOsd{'NCFlags'} & 0x08) { $Mode = "$Mode" . " !"};  # Range Warning
        $map_canvas->itemconfigure ('MK-OSD-Mode-Value', '-text' => "$Mode" );
 
        # Holdtime count down
        if ( $WpPlayerHoldtime >= 0 )
            {
            my $Holdtime = int ($WpPlayerHoldtime / 2  + 0.5);
            $map_canvas->itemconfigure ('MK-OSD-Holdtime-Value', '-text' => sprintf ("%d s", $Holdtime) );
            $map_canvas->coords ('MK-OSD-Holdtime-Label', $MapSizeX - 130, 110);
            $map_canvas->coords ('MK-OSD-Holdtime-Value', $MapSizeX - 80, 110);
            }
        else
            {
            # move out of sight
            $map_canvas->coords ('MK-OSD-Holdtime-Label', $MapSizeX - 130, -110);
            $map_canvas->coords ('MK-OSD-Holdtime-Value', $MapSizeX - 80, -110);
            }
 
 
        # Farbe MK-Zeiger abhängig vom GPS Empfang
        my $MkCol= $Cfg->{'mkcockpit'}->{'ColorMkSatNo'};
        if ( $SatsInUse >= 1 ) { $MkCol = $Cfg->{'mkcockpit'}->{'ColorMkSatLow'} ; }
        if ( $SatsInUse >= 6 ) { $MkCol = $Cfg->{'mkcockpit'}->{'ColorMkSatGood'}; }
        $map_canvas->itemconfigure ('MK-Arrow', '-fill' => $MkCol);
 
        # Variometer Pointer
        my $dy = -$MkOsd{'Variometer'} * 10;
        $map_canvas->coords('Map-Variometer-Pointer', 5, $MapSizeY/2+$dy, 20, $MapSizeY/2+10+$dy, 20, $MapSizeY/2-10+$dy);
               
        # Show/Hide SatFix Icon
        if ($MkOsd{'SatsInUse'} >= 6 )
            {
            $map_canvas->coords('Satellite', $MapSizeX-190, 10, );
            }
        else
            {
            # move icon out of sight
            $map_canvas->coords('Satellite', 0, -100, );
            }
        }
    else
        {
        # keine aktuellen OSD Daten vom MK verfügbar
        }
 
    });
 
#       
# Timer: 0.1s - Tracking Anzeige aktualisieren
#
if ( $Cfg->{'track'}->{'Active'} =~ /y/i )
    {
    $frame_map_top->repeat (100, sub
        {
        # Aktuell gültige Karte
        my %Map = %{$Maps{'Current'}};
 
        # Zeiger neu zeichnen
        my $ServoPan = @ServoPos[$MkTrack{'ServoPan'}];
        if ( $ServoPan ne ""  )
            {
            my $x0 = $TrackSizeX/2;    
            my $y0 = $TrackSizeY - 0 - $TrackOffY;
            my $x1 = $TrackSizeX/2 - ($TrackPtrLen-22) * cos( deg2rad $ServoPan);
            my $y1 = $TrackSizeY   - ($TrackPtrLen-22) * sin (deg2rad $ServoPan) - $TrackOffY;
            $track_canvas->coords ('Track-Ptr', $x0, $y0, $x1, $y1);
            }
 
        # Farbe Zeiger abhängig vom GPS Empfang
        my $SatsInUse = $MkOsd{'SatsInUse'};
        my $TrackPtrCol= 'red';
        if ( $SatsInUse >= 1 ) { $TrackPtrCol = 'orange'; }
        if ( $SatsInUse >= 6 ) { $TrackPtrCol = 'green'; }
        $track_canvas->itemconfigure ('Track-Ptr', '-fill' => $TrackPtrCol);
        });
    }
 
 
#       
# Timer: 0.5s - Waypoint Player
#
$frame_map_top->repeat (500, sub
    {
    if ($MkOsd{'NCFlags'} & 0x04)
        {
        # NC is in WPT Mode 
 
        if ( $WpPlayerMode eq "Pause" )
            {
            if ( $WpPlayerPause_Lat ne ""  and  $WpPlayerPause_Lon ne "" )
                {
                # Gespeicherte Pausen-Pos senden
                &MkFlyTo ( '-lat'  => $WpPlayerPause_Lat,
                           '-lon'  => $WpPlayerPause_Lon,
                           '-holdtime' => "60",
                           '-mode' => "Target",
                         );
                }
            }
 
        if ( $WpPlayerMode eq "Home" )
            {
            lock (%MkOsd);              # until end of block
            if ( $MkOsd{'HomePos_Stat'} == 1 )
                {
                &MkFlyTo ( '-lat'  => $MkOsd{'HomePos_Lat'},
                           '-lon'  => $MkOsd{'HomePos_Lon'},
                           '-holdtime' => "60",
                           '-mode' => "Target",
                         );
                }
            }
 
        my $WpCnt = scalar @Waypoints;
        if ( $WpPlayerMode eq "Play"  and  $WpCnt > 0  and  $WpPlayerIndex < $WpCnt )
            {
            # Target WP-Pos senden
            my $Wp_Lon = $Waypoints[$WpPlayerIndex]{'Pos_Lon'};
            my $Wp_Lat = $Waypoints[$WpPlayerIndex]{'Pos_Lat'};
            if ( $Wp_Lat ne ""  and  $Wp_Lon ne "" )
                {
                &MkFlyTo ( '-lat'  => $Wp_Lat,
                           '-lon'  => $Wp_Lon,
                           '-holdtime' => "60",
                           '-mode' => "Target",
                         );
                }
            }
   
        if ( $WpPlayerMode eq "Play" )
            {
            # Ziel erreicht?
            if ( &WpCheckTargetReached() )
                {
                &WpTargetNext();
                }
            }
        }
 
    # WP Player Holdtime count down
    if ( $WpPlayerHoldtime > 0  )
        {
        $WpPlayerHoldtime --;
        }
    });
 
 
#       
# Timer: 1s
#
$frame_map_top->repeat (1000, sub
    {
    # Aktuell gültige Karte
    my %Map = %{$Maps{'Current'}};
 
    if ( $MkOsd{'_Timestamp'} >= time -2 )
        {
 
        # Heartbeat MK Datenübertragung
        if ( time %2 )
            {
            $map_canvas->itemconfigure('Heartbeat', '-image' => 'HeartbeatLarge', );
            }
        else
            {
            $map_canvas->itemconfigure('Heartbeat', '-image' => 'HeartbeatSmall', );
            }
 
        # Flugzeit aktualisieren
        # Flugzeit selber mitzählen, da $MkOsd{'FlyingTime'} immer 0 (0.14b)
        if ( $MkOsd{'MKFlags'} & 0x02 )
            {
            $MkFlyingTime += 1;
            }
 
        # Footprint
        if ( $Cfg->{'mkcockpit'}->{'FootprintLength'} > 0 )
            {
            if ( $MkOsd{'SatsInUse'} > 0  and  $MkOsd{'CurPos_Stat'} == 1 )
                {
                # neuen Footprint hinten anhaengen
                my ($x, $y) = &MapGps2XY($MkOsd{'CurPos_Lat'}, $MkOsd{'CurPos_Lon'});
                push @Footprint, $x, $y;
                }
 
            while ( $#Footprint / 2  >  $Cfg->{'mkcockpit'}->{'FootprintLength'} )
                {
                # alte Footprints entfernen
                splice @Footprint, 0, 2;
                }
 
            &FootprintRedraw();
            }
 
 
        # tracking antenne
        if ( $MkOsd{'MKFlags'} & 0x01  and  ! $MkTrack{'IsRunning'} and
             $Cfg->{'track'}->{'Active'} =~ /y/i )
            {
            # start track at 1st motor start
            $track_thr = threads->create (\&TrackAntennaGps)->detach();
            $MkTrack{'IsRunning'} = "Running";
            }
        }
    });
 
 
MainLoop();   # should never end
 
 
#-----------------------------------------------------------------
# Subroutines
#-----------------------------------------------------------------                        
 
# Get Wp Index from Canvas Id
sub WpGetIndexFromId()
    {
    my ($id) = @_;
 
    my @Tags = $map_canvas->gettags($id);
    my $WpTag = $Tags[1];
 
    for $i (0 .. $#Waypoints)
        {
        my $Wp = $Waypoints[$i];
        if ( $Wp->{'Tag'} eq $WpTag )
            {
            # got it
            return $i;
            }
        }
    return -1;
    }
 
       
# Resend all Waypoints to MK
sub WpSendAll()
    {
    # OSD/Debug Query Frequency verringern, sonst kommen nicht alle Wp im MK an
    # Sicherheitshalber doppelt senden
    $MkSendWp = 1;       # verhindert ueberschreiben im Timer
    $MkSendQueue->enqueue( "o", "$AddrNC", pack ("C", 1000) );   # Frequency OSD Record, * 10ms
    $MkSendQueue->enqueue( "d", "$AddrNC", pack ("C", 1000) );   # Frequency MK Debug Record, * 10ms
    usleep (200000);
    $MkSendQueue->enqueue( "o", "$AddrNC", pack ("C", 1000) );   # Frequency OSD Record, * 10ms
    $MkSendQueue->enqueue( "d", "$AddrNC", pack ("C", 1000) );   # Frequency MK Debug Record, * 10ms
    usleep (200000);
 
    # Alte WP-Liste im MK löschen
    my $Wp = $Waypoints[0];
    &MkFlyTo ( '-lat'  => $Wp->{'Pos_Lat'},
               '-lon'  => Wp->{'Pos_Lon'},
               '-mode' => "Waypoint Delete"
             );
               
    for $i (0 .. $#Waypoints)
        {
        my $Wp = $Waypoints[$i];
        &MkFlyTo ( '-lat'             => $Wp->{'Pos_Lat'},
                   '-lon'             => $Wp->{'Pos_Lon'},
                   '-alt'             => $Wp->{'Pos_Alt'},
                   '-heading'         => $Wp->{'Heading'},
                   '-toleranceradius' => $Wp->{'ToleranceRadius'},
                   '-holdtime'        => $Wp->{'Holdtime'},
                   '-eventflag'       => $Wp->{'Event_Flag'},
                   '-mode'            => "Waypoint"
                 );
               
        usleep (150000)  # NC Zeit zum Verarbeiten geben
        }
 
    $MkSendWp = 0;  # normale OSD/Debug Query Frequency wird automatisch im 5s Timer wieder eingestellt
 
    # gray connectors: Wp are sent to MK
    $map_canvas->itemconfigure('Waypoint-Connector',
                               '-fill' => $Cfg->{'mkcockpit'}->{'ColorWpConnector'},
                              );
 
    # MK ist nun synchron mit @Waypoints
    $WaypointsModified = 0;
    }          
 
       
# Redraw Waypoint Icons
sub WpRedrawIcons()
    {
    # delete old icons and Wp-Number from canvas
    $map_canvas->delete('Waypoint');
    $map_canvas->delete('WaypointNumber');
 
    # create new icons
    for $i (0 .. $#Waypoints)
        {
        my $Wp = $Waypoints[$i];
        my $x = $Wp->{'MapX'};
        my $y = $Wp->{'MapY'};
        my $Tag = $Wp->{'Tag'};
 
        # Waypoint Icon
        my $IconHeight = 48;
        my $IconWidth = 48;
        $map_canvas->createImage($x-$IconWidth/2, $y-$IconHeight,
                                 '-tags' => ['Waypoint', $Tag],
                                 '-anchor' => 'nw',
                                 '-image'  => 'Waypoint-Photo',
                                );
        # Waypoint Number
        my $WpNumber = $i + 1;
        $map_canvas->createText ( $x+3, $y-$IconHeight/2+12,
                                  '-tags' => ['WaypointNumber', $Tag],
                                  '-text' => $WpNumber,
                                  '-font' => '-*-Arial-Bold-R-Normal--*-100-*',
                                  '-fill' => $Cfg->{'mkcockpit'}->{'ColorWpNumber'},
                                  '-anchor' => 'w',
                                 );    
 
        }      
    $map_canvas->lower('Waypoint', 'Fox');              # waypoint below Fox
    $map_canvas->lower('WaypointNumber', 'Waypoint');   # waypoint-number below waypoint
    }
 
       
# Redraw Waypoint connectors
sub WpRedrawLines()
    {
    # delete old connectors from canvas
    $map_canvas->delete('Waypoint-Connector');  
 
    my $Color = $Cfg->{'mkcockpit'}->{'ColorWpConnector'};
    if ( $WaypointsModified )
        {
        $Color = $Cfg->{'mkcockpit'}->{'ColorWpResend'};
        }
 
    my $Wp = $Waypoints[0];
    my $x_last = $Wp->{'MapX'};
    my $y_last = $Wp->{'MapY'};
    for $i (1 .. $#Waypoints)
        {
        my $Wp = $Waypoints[$i];
        my $x = $Wp->{'MapX'};
        my $y = $Wp->{'MapY'};
 
        $map_canvas->createLine ( $x_last, $y_last, $x, $y,
                                  '-tags' => 'Waypoint-Connector',
                                  '-arrow' => 'last',
                                  '-arrowshape' => [10, 10, 3 ],
                                  '-fill' => $Color,
                                  '-width' => 1,
                                );                                               
        $x_last = $x;
        $y_last = $y;
        }
               
    $map_canvas->lower('Waypoint-Connector', 'Waypoint');   # connector below waypoint
    }
 
 
# Redraw Footprint
sub FootprintRedraw()
    {
    # delete old Footprint fom canvas
    $map_canvas->delete('Footprint');  
 
    if ( scalar @Footprint >= 4 )  # at least 2 Koordinaten-Paare
        {
        $map_canvas->createLine ( @Footprint,
                                  '-tags' => 'Footprint',
                                  '-fill' => $Cfg->{'mkcockpit'}->{'ColorFootprint'},
                                  '-width' => 1,
                                );       
        }
               
    $map_canvas->lower('Footprint', 'Fox');
    }
 
 
# Display or Modify Hash
sub DisplayHash()
    {
    my ($hrefData, $Titel, $Mode) = @_;
 
    # $Mode: Display, Edit, Waypoint, Refresh
 
    my %Id;
    my $Label;
    my $Value;
 
    # Neues Fenster aufmachen
    my $popup = $main->Toplevel();
    $popup->title($Titel);
       
    # Buttons
    my $popup_button = $popup->Frame() -> pack('-side' => 'bottom',
                                               '-expand' => 'y',
                                               '-anchor' => 's',
                                               '-padx' => 5,
                                               '-pady' => 5,
                                               );
    $popup_button->Button('-text'    => 'Close',
                          '-command' => sub
        {
        if ( $Mode =~ /edit/i  and  $Mode =~ /waypoint/i )
            {
            $WaypointsModified = 1;            
            &WpRedrawLines();
            &WpRedrawIcons();
            }
 
        $popup->destroy()
        })->pack;
 
    # Frame mit den Labels
    my $popup_label = $popup->Frame() -> pack('-side' => 'left',
                                              '-expand' => 'y',
                                              '-anchor' => 'w',
                                              '-padx' => 10,
                                              '-pady' => 10,
                                              );
    # Labels anzeigen                    
    foreach $Label ( sort keys %{$hrefData})
        {
        if ( $Translate{$Label} ne "" )
            {
            $Label = $Translate{$Label};
            }
                       
        $popup_label->Label ('-text' => $Label,
                             '-width' => 25,
                             '-anchor' => 'w',
                             ) -> pack();
        }
       
    # Frame mit den Daten
    my $popup_values = $popup->Frame() -> pack('-side' => 'left',
                                               '-expand' => 'y',
                                               '-anchor' => 'w',
                                               '-padx' => 10,
                                               '-pady' => 10,
                                               );
    # Daten anzeigen
    foreach $Value ( sort keys %{$hrefData})
        {                              
        if ( $Mode =~ /display/i )
            {
            # Display
            $Id{$Value} = $popup_values->Label ('-text' => ${$hrefData}{$Value},
                                                '-width' => 20,
                                                '-anchor' => 'e',
                                                '-relief' => 'sunken',
                                                ) -> pack();
            }
        if ( $Mode =~ /edit/i )
            {
            # Edit
            $Id{$Value} = $popup_values->Entry ('-textvariable' => \${$hrefData}{$Value},
                                                '-exportselection' => '1',
                                                '-width' => 20,
                                                '-relief' => 'sunken',
                                               ) -> pack();
            if ( $Mode =~ /waypoint/i )
                {
                # einige Waypoint-Felder nicht aenderbar einstellen
                if ( "MapX MapY Pos_Lat Pos_Lon Tag" =~ /$Value/i )
                    {
                    $Id{$Value}->configure('-state' => 'disabled', );
                    }
                }      
            }
        }
 
    if ( $Mode =~ /refresh/i )
        {
        # Timer: 0.1s
        $popup_values->repeat (100, sub
            {
            # Datenfelder alle 100ms aktualisieren
 
            my $BgColor = 'white';
            if ( $Mode =~ /heartbeat/i )
                {
                $BgColor = 'red';
                if ( $MkOsd{'_Timestamp'} >= time-2 )
                    {
                    # gültige daten vom MK
                    $BgColor = 'white';
                    }
                }
               
            foreach $Value ( sort keys %{$hrefData} )
                {
                $Id{$Value}->configure('-text' => ${$hrefData}{$Value},
                                       '-background' => "$BgColor",
                                      );
                }
            });
        }
 
    return 0;
    }
 
 
 
# KonfigurationsClose mkcockpit.xml im Popup-Fenster editieren
sub Configure()
    {
 
    # Copy Cfg-Hash for editing
    my $CfgEdit = {%{$Cfg}};
    foreach $key (keys %{$Cfg})
        {
        if ( ref $Cfg->{$key} )
            {
            $CfgEdit->{$key} = {%{$Cfg->{$key}}};
            }
        }
 
    # Neues Fenster aufmachen
    my $popup = $main->Toplevel();
    $popup->title("Preferences - $XmlConfigFile");
 
    # jede Sektion in einem Tab anzeigen
    my $book = $popup->NoteBook()->pack( -fill=>'both', -expand=>1 );
    foreach $key (sort keys %{$CfgEdit})
        {    
        if ( ! ref $CfgEdit->{$key} )
            {
            next;
            }
 
        my $TabLabel = "$key";
        if ( $Translate{$key} ne "" )
                {
                $TabLabel = $Translate{$key};
                }
 
        my $Tab = $book->add( "$key", -label=>"$TabLabel", );
 
        # Frame fuer Buttons
        my $book_button = $Tab->Frame() -> pack('-side' => 'bottom',
                                                '-expand' => 'y',
                                                '-anchor' => 's',
                                                '-padx' => 5,
                                                '-pady' => 5,
                                                );
 
        $book_button->Button('-text'    => 'OK',
                             '-width' => '10',
                             '-command' => sub
            {
            # Copy back CfgEdit-Hash
            $Cfg = {%{$CfgEdit}};
            foreach $key (keys %{$CfgEdit})
                {
                if ( ref $CfgEdit->{$key} )
                    {
                    $Cfg->{$key} = {%{$CfgEdit->{$key}}};
                    }
                }
 
            # set new timestamp
            my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime(time);
            my $TimeStamp = sprintf ("%04d%02d%02d-%02d%02d%02d", $year+1900, $mon+1, $mday, $hour, $min, $sec);
            $Cfg->{'CreationDate'} = $TimeStamp;
 
            # Cfg in mkcockpit.xml speichern
            &XMLout ($Cfg,
                     'OutputFile' => $XmlConfigFile,
                     'AttrIndent' => '1',
                     'RootName' => 'mkcockpit-Config',
                    );
 
            $popup->destroy();
            } )->pack ('-side' => 'left',
                       '-expand' => 'y',
                       '-anchor' => 's',
                       '-padx' => 5,
                       '-pady' => 5,
                      );
        $book_button->Button('-text'    => 'Abort',
                             '-width' => '10',
                             '-command' => sub { $popup->destroy() },
                            )->pack ('-side' => 'left',
                                     '-expand' => 'y',
                                     '-anchor' => 's',
                                     '-padx' => 5,
                                     '-pady' => 5,
                                     );
        $book_button->Label ('-text' => "*) Changes are effective only after program restart!",
                             '-anchor' => 'w',
                             '-foreground' => 'red',
                            ) ->pack ('-side' => 'left',
                                      '-expand' => 'y',
                                      '-anchor' => 's',
                                      '-padx' => 10,
                                      '-pady' => 5,
                                      );
 
        # Frame mit den Labels
        my $popup_label = $Tab->Frame() -> pack('-side' => 'left',
                                                '-expand' => 'y',
                                                '-anchor' => 'w',
                                                '-padx' => 10,
                                                '-pady' => 10,
                                                );
        # Labels anzeigen                        
        foreach $Label ( sort keys %{$CfgEdit->{$key}})
            {
            if ( $Translate{$Label} ne "" )
                {
                $Label = $Translate{$Label};
                }
               
            $popup_label->Label ('-text' => $Label,
                                 '-width' => 30,
                                 '-anchor' => 'w',
                                ) -> pack();
            }
 
        # Frame mit den Daten
        my $popup_values = $Tab->Frame() -> pack('-side' => 'left',
                                                 '-expand' => 'y',
                                                 '-anchor' => 'w',
                                                 '-padx' => 10,
                                                 '-pady' => 10,
                                                 );
        # Eingabefelder mit Daten anzeigen
        foreach $Value ( sort keys %{$CfgEdit->{$key}})
            {                          
            $popup_values->Entry ('-textvariable' => \$CfgEdit->{$key}->{$Value},
                                  '-exportselection' => '1',
                                  '-width' => 30,
                                  '-relief' => 'sunken',
                                 ) -> pack();  
            }
        }
    }
 
 
# Waypoint Player: Goto next Waypoint
sub WpTargetNext()
    {
    $WpPlayerIndex ++;
    if ( $WpPlayerIndex > $#Waypoints )
        {
        # Restart with 1st Wp
        $WpPlayerIndex = 0;
        }
 
    $WpPlayerHoldtime = -1;
    }
 
# Waypoint Player: Goto previous Waypoint
sub WpTargetPrev()
    {
    $WpPlayerIndex --;
    if ( $WpPlayerIndex < 0 )
        {
        # Restart with last Wp
        $WpPlayerIndex = $#Waypoints;
        }
 
    $WpPlayerHoldtime = -1;
    }
 
# Waypoint Player: Goto first Waypoint
sub WpTargetFirst()
    {
    $WpPlayerIndex = 0;
    $WpPlayerHoldtime = -1;
    }
 
# Waypoint Player: Goto last Waypoint
sub WpTargetLast()
    {
    $WpPlayerIndex = $#Waypoints;
    $WpPlayerHoldtime = -1;
    }
 
 
# Waypoint Player: Waypoint Target reached?
sub WpCheckTargetReached()
    {
    if ( $WpPlayerHoldtime == -1 )
        {
        lock (%MkOsd);              # until end of block
 
        if ( $MkOsd{'_Timestamp'} >= time-2  and   # Gueltige OSD Daten
             $MkOsd{'NCFlags'} & 0x04  and         # WPT-Mode
             $MkOsd{'SatsInUse'} >= 6  and  $MkOsd{'CurPos_Stat'} == 1 and  $MkOsd{'HomePos_Stat'} == 1)
            {
            # Gueltige SAT Daten
            my $WpTarget_Lat = $Waypoints[$WpPlayerIndex]{'Pos_Lat'};
            my $WpTarget_Lon = $Waypoints[$WpPlayerIndex]{'Pos_Lon'};
            my $WpTolerance  = $Waypoints[$WpPlayerIndex]{'ToleranceRadius'};
            my $WpHoldtime   = $Waypoints[$WpPlayerIndex]{'Holdtime'};
 
            # Operation Radius pruefen
            my ($HomeDist, $HomeBearing) = &MapGpsTo($MkOsd{'HomePos_Lat'}, $MkOsd{'HomePos_Lon'}, $WpTarget_Lat, $WpTarget_Lon );
            if ( $HomeDist > $MkOsd{'OperatingRadius'} )
                {
                # Target entsprechend Operation Radius neu berechnen
                $HomeDist = $MkOsd{'OperatingRadius'};
                ($WpTarget_Lat, $WpTarget_Lon) = &MapGpsAt($MkOsd{'HomePos_Lat'}, $MkOsd{'HomePos_Lon'}, $HomeDist, $HomeBearing);
                }
 
 
            # Abstand zum Ziel pruefen
            my ($Dist, $Bearing) = &MapGpsTo($MkOsd{'CurPos_Lat'}, $MkOsd{'CurPos_Lon'}, $WpTarget_Lat, $WpTarget_Lon );
            if ( $Dist <= $WpTolerance )
                {
                # Target reached - count down Holdtime
                $WpPlayerHoldtime = 2 * $WpHoldtime;      # 0..2n - decrement im 0.5s timer
                }
            }
        }
 
    if ( $WpPlayerHoldtime == 0 )  # wird im 0.5s timer runtergezaehlt
        {
        # Target reached - Holdtime is over
        $WpPlayerHoldtime = -1;
        return 1;
        }
 
    # Target NOT reached
    return 0;
    }
 
 
#
# Call Back
# 
 
# Wp-Player CallBack: Play/Pause button
sub CbWpPlayerPlayPause()
    {
    # Play/Pause-Icon loeschen und neu anzeigen
    $map_canvas->delete('Wp-PlayPause');
 
    if ( ($WpPlayerMode eq "Pause") or  ($WpPlayerMode eq "Stop") or  ($WpPlayerMode eq "Home") )
        {
        $WpPlayerMode = 'Play';
        $WpPlayerHoldtime = -1;
        $map_canvas->createImage($MapSizeX/2+100, $MapSizeY-48,
                                 '-tags' => 'Wp-PlayPause',
                                 '-anchor' => 'nw',
                                 '-image'  => 'WpPause-Foto',
                                 );
        }
    else
        {
        $WpPlayerMode = 'Pause';
        $WpPlayerHoldtime = -1;
        $map_canvas->createImage($MapSizeX/2+100, $MapSizeY-48,
                                 '-tags' => 'Wp-PlayPause',
                                 '-anchor' => 'nw',
                                 '-image'  => 'WpPlay-Foto',
                                 );
 
        # momentane Position merken und im Wp-Timer dauernd senden
        $WpPlayerPause_Lon = "";
        $WpPlayerPause_Lat = "";
 
        lock (%MkOsd);              # until end of block
        if ( $MkOsd{'_Timestamp'} >= time-2 )
            {
            # Gueltige OSD Daten
            if ( $MkOsd{'SatsInUse'} >= 6  and  $MkOsd{'CurPos_Stat'} == 1 )
                {
                $WpPlayerPause_Lon = $MkOsd{'CurPos_Lon'};
                $WpPlayerPause_Lat = $MkOsd{'CurPos_Lat'};
                }
            }
        }
    }
 
 
# Wp-Player CallBack: Next
sub CbWpPlayerNext()
    {
    if ( $WpPlayerMode ne 'Stop' )
        {
        &WpTargetNext();
        }
    }
 
 
# Wp-Player CallBack: Prev
sub CbWpPlayerPrev()
    {
    if ( $WpPlayerMode ne 'Stop' )
        {
        &WpTargetPrev();
        }
    }
 
 
# Wp-Player CallBack: First
sub CbWpPlayerFirst()
    {
    if ( $WpPlayerMode ne 'Stop' )
        {
        &WpTargetFirst();
        }
    }
 
# Wp-Player CallBack: Last
sub CbWpPlayerLast()
    {
    if ( $WpPlayerMode ne 'Stop' )
        {
        &WpTargetLast();
        }
    }
 
 
# Wp-Player CallBack: Home
sub CbWpPlayerHome()
    {
    if ( $WpPlayerMode ne 'Stop' )
        {
        $WpPlayerMode = 'Home';
        &WpTargetFirst();
 
        $map_canvas->delete('Wp-PlayPause');
        $map_canvas->createImage($MapSizeX/2+100, $MapSizeY-48,
                                 '-tags' => 'Wp-PlayPause',
                                 '-anchor' => 'nw',
                                 '-image'  => 'WpPlay-Foto',
                                 );
        }
    }
 
 
# Wp-Player CallBack: Stop
sub CbWpPlayerStop()
    {
    if ( $WpPlayerMode ne 'Stop' )
        {
        $WpPlayerMode = 'Stop';
        &WpFirstFirst();
 
        $map_canvas->delete('Wp-PlayPause');
        $map_canvas->createImage($MapSizeX/2+100, $MapSizeY-48,
                                 '-tags' => 'Wp-PlayPause',
                                 '-anchor' => 'nw',
                                 '-image'  => 'WpPlay-Foto',
                                 );
 
        # Show user that Waypoints in MK are cleared
        $WaypointsModified = 1;
        &WpRedrawLines();
        }
    }
 
 
1;
__END__
 

Rev 475	Rev 476
1	#!/usr/bin/perl	1	#!/usr/bin/perl
2	#y!/usr/bin/perl -d:ptkdb	2	#y!/usr/bin/perl -d:ptkdb
3		3
4	###############################################################################	4	###############################################################################
5	#	5	#
6	# mkcockpit.pl - MK Mission Cockpit - GUI	6	# mkcockpit.pl - MK Mission Cockpit - GUI
7	#	7	#
8	# Copyright (C) 2009 Rainer Walther (rainerwalther-mail@web.de)	8	# Copyright (C) 2009 Rainer Walther (rainerwalther-mail@web.de)
9	#	9	#
10	# Creative Commons Lizenz mit den Zusaetzen (by, nc, sa)	10	# Creative Commons Lizenz mit den Zusaetzen (by, nc, sa)
11	#	11	#
12	# Es ist Ihnen gestattet:	12	# Es ist Ihnen gestattet:
13	# * das Werk vervielfältigen, verbreiten und öffentlich zugänglich machen	13	# * das Werk vervielfältigen, verbreiten und öffentlich zugänglich machen
14	# * Abwandlungen bzw. Bearbeitungen des Inhaltes anfertigen	14	# * Abwandlungen bzw. Bearbeitungen des Inhaltes anfertigen
15	#	15	#
16	# Zu den folgenden Bedingungen:	16	# Zu den folgenden Bedingungen:
17	# * Namensnennung.	17	# * Namensnennung.
18	# Sie müssen den Namen des Autors/Rechteinhabers in der von ihm festgelegten Weise nennen.	18	# Sie müssen den Namen des Autors/Rechteinhabers in der von ihm festgelegten Weise nennen.
19	# * Keine kommerzielle Nutzung.	19	# * Keine kommerzielle Nutzung.
20	# Dieses Werk darf nicht für kommerzielle Zwecke verwendet werden.	20	# Dieses Werk darf nicht für kommerzielle Zwecke verwendet werden.
21	# * Weitergabe unter gleichen Bedingungen.	21	# * Weitergabe unter gleichen Bedingungen.
22	# Wenn Sie den lizenzierten Inhalt bearbeiten oder in anderer Weise umgestalten,	22	# Wenn Sie den lizenzierten Inhalt bearbeiten oder in anderer Weise umgestalten,
23	# verändern oder als Grundlage für einen anderen Inhalt verwenden,	23	# verändern oder als Grundlage für einen anderen Inhalt verwenden,
24	# dürfen Sie den neu entstandenen Inhalt nur unter Verwendung von Lizenzbedingungen	24	# dürfen Sie den neu entstandenen Inhalt nur unter Verwendung von Lizenzbedingungen
25	# weitergeben, die mit denen dieses Lizenzvertrages identisch oder vergleichbar sind.	25	# weitergeben, die mit denen dieses Lizenzvertrages identisch oder vergleichbar sind.
26	#	26	#
27	# Im Falle einer Verbreitung müssen Sie anderen die Lizenzbedingungen, unter welche dieses	27	# Im Falle einer Verbreitung müssen Sie anderen die Lizenzbedingungen, unter welche dieses
28	# Werk fällt, mitteilen. Am Einfachsten ist es, einen Link auf diese Seite einzubinden.	28	# Werk fällt, mitteilen. Am Einfachsten ist es, einen Link auf diese Seite einzubinden.
29	#	29	#
30	# Jede der vorgenannten Bedingungen kann aufgehoben werden, sofern Sie die Einwilligung	30	# Jede der vorgenannten Bedingungen kann aufgehoben werden, sofern Sie die Einwilligung
31	# des Rechteinhabers dazu erhalten.	31	# des Rechteinhabers dazu erhalten.
32	#	32	#
33	# Diese Lizenz lässt die Urheberpersönlichkeitsrechte unberührt.	33	# Diese Lizenz lässt die Urheberpersönlichkeitsrechte unberührt.
34	#	34	#
35	# Weitere Details zur Lizenzbestimmung gibt es hier:	35	# Weitere Details zur Lizenzbestimmung gibt es hier:
36	# Kurzform: http://creativecommons.org/licenses/by-nc-sa/3.0/de/	36	# Kurzform: http://creativecommons.org/licenses/by-nc-sa/3.0/de/
37	# Komplett: http://creativecommons.org/licenses/by-nc-sa/3.0/de/legalcode	37	# Komplett: http://creativecommons.org/licenses/by-nc-sa/3.0/de/legalcode
38	#	38	#
39	###############################################################################	39	###############################################################################
40	# 2009-02-20 0.0.1 rw created	40	# 2009-02-20 0.0.1 rw created
41	# 2009-04-01 0.1.0 rw RC1	41	# 2009-04-01 0.1.0 rw RC1
42	# 2009-04-16 0.1.1 rw Bugfix, ALT= average of airsensor and Sat	42	# 2009-04-16 0.1.1 rw Bugfix, ALT= average of airsensor and Sat
43	# 2009-05-14 0.2.0 rw Waypoint Player	43	# 2009-05-14 0.2.0 rw Waypoint Player
44	#	-
-		44	# 2009-05-25 0.2.1 rw Modified screen text to English by Mark Griffin
45	###############################################################################	45	###############################################################################
46		46
47	$Version = "0.2.0 - 2009-05-14";	47	$Version = "0.2.1 - 2009-05-25";
48		48
49	use threads; # http://search.cpan.org/~jdhedden/threads-1.72/threads.pm	49	use threads; # http://search.cpan.org/~jdhedden/threads-1.72/threads.pm
50	# http://perldoc.perl.org/threads.html	50	# http://perldoc.perl.org/threads.html
51	use threads::shared; # http://search.cpan.org/~jdhedden/threads-shared-1.28/shared.pm	51	use threads::shared; # http://search.cpan.org/~jdhedden/threads-shared-1.28/shared.pm
52	use Thread::Queue; # http://search.cpan.org/dist/Thread-Queue-2.11/lib/Thread/Queue.pm	52	use Thread::Queue; # http://search.cpan.org/dist/Thread-Queue-2.11/lib/Thread/Queue.pm
53	use Tk;	53	use Tk;
54	use Tk::Balloon;	54	use Tk::Balloon;
55	use Tk::Dialog;	55	use Tk::Dialog;
56	use Tk::Notebook;	56	use Tk::Notebook;
57	use Math::Trig;	57	use Math::Trig;
58	use Time::HiRes qw(usleep); # http://search.cpan.org/~jhi/Time-HiRes-1.9719/HiRes.pm	58	use Time::HiRes qw(usleep); # http://search.cpan.org/~jhi/Time-HiRes-1.9719/HiRes.pm
59	use XML::Simple; # http://search.cpan.org/dist/XML-Simple-2.18/lib/XML/Simple.pm	59	use XML::Simple; # http://search.cpan.org/dist/XML-Simple-2.18/lib/XML/Simple.pm
60		60
61	# change working directory to program path	61	# change working directory to program path
62	my $Cwd = substr ($0, 0, rindex ($0, "mkcockpit.pl"));	62	my $Cwd = substr ($0, 0, rindex ($0, "mkcockpit.pl"));
63	chdir $Cwd;	63	chdir $Cwd;
64		64
65	# set path for local Perl libs	65	# set path for local Perl libs
66	push @INC, $Cwd . "perl/lib", $Cwd . "perl/site/lib";	66	push @INC, $Cwd . "perl/lib", $Cwd . "perl/site/lib";
67		67
68	# Version setting	68	# Version setting
69	share (%Version);	69	share (%Version);
70	$Version{'mkcockpit.pl'} = $Version;	70	$Version{'mkcockpit.pl'} = $Version;
71		71
72	# Read configuration	72	# Read configuration
73		73
74	$XmlConfigFile = "mkcockpit.xml";	74	$XmlConfigFile = "mkcockpit.xml";
75	$Cfg = XMLin($XmlConfigFile);	75	$Cfg = XMLin($XmlConfigFile);
76		76
77	require "track.pl"; # Tracking antenna	77	require "track.pl"; # Tracking antenna
78	require "mkcomm.pl"; # MK communication	78	require "mkcomm.pl"; # MK communication
79	require "logging.pl"; # CSV and GPX Logging	79	require "logging.pl"; # CSV and GPX Logging
80	require "geserver.pl"; # Google Earth Server	80	require "geserver.pl"; # Google Earth Server
81	require "$Cfg->{'map'}->{'MapDir'}/map.pl"; # Landkarte	81	require "$Cfg->{'map'}->{'MapDir'}/map.pl"; # Landkarte
82	require "libmap.pl"; # map subs	82	require "libmap.pl"; # map subs
83	require "translate.pl"; # Übersetzungstable	83	require "translate.pl"; # Übersetzungstable
84		84
85	# Thread fuer Kommunikation mit MK starten	85	# Thread fuer Kommunikation mit MK starten
86	# Output: %MkOsd, %MkTarget, %MkNcDebug, %Mk	86	# Output: %MkOsd, %MkTarget, %MkNcDebug, %Mk
87	# Input: Thread-Queue: $MkSendQueue	87	# Input: Thread-Queue: $MkSendQueue
88	$mk_thr = threads->create (\&MkCommLoop) -> detach();	88	$mk_thr = threads->create (\&MkCommLoop) -> detach();
89		89
90	# Start Logging Thread	90	# Start Logging Thread
91	$log_thr = threads->create (\&MkLogLoop) -> detach();	91	$log_thr = threads->create (\&MkLogLoop) -> detach();
92		92
93	# Start GoogleEarth Thread	93	# Start GoogleEarth Thread
94	$ge_thr = threads->create (\&GeServer) -> detach();	94	$ge_thr = threads->create (\&GeServer) -> detach();
95		95
96	# Aktuell gültige Karte	96	# Aktuell gültige Karte
97	my %Map = %{$Maps{'Current'}};	97	my %Map = %{$Maps{'Current'}};
98		98
99	# Hauptfenster	99	# Hauptfenster
100	my $main = new MainWindow;	100	my $main = new MainWindow;
101	$main->title ("MK Mission Cockpit");	101	$main->title ("MK Mission Cockpit");
102		102
103	#-----------------------------------------------------------------	103	#-----------------------------------------------------------------
104	# Menu	104	# Menu
105	#-----------------------------------------------------------------	105	#-----------------------------------------------------------------
106		106
107	# Menu bar	107	# Menu bar
108	my $menu_bar = $main->Menu;	108	my $menu_bar = $main->Menu;
109	$main->optionAdd("*tearOff", "false");	109	$main->optionAdd("*tearOff", "false");
110	$main->configure ('-menu' => $menu_bar);	110	$main->configure ('-menu' => $menu_bar);
111		111
112	my $menu_file = $menu_bar->cascade('-label' => "~File");	112	my $menu_file = $menu_bar->cascade('-label' => "~File");
113	$menu_file->command('-label' => 'Preferences',	113	$menu_file->command('-label' => 'Preferences',
114	'-command' => [\&Configure],	114	'-command' => [\&Configure],
115	);	115	);
116	$menu_file->separator;	116	$menu_file->separator;
117	$menu_file->command('-label' => 'E~xit',	117	$menu_file->command('-label' => 'E~xit',
118	'-command' => sub{exit(0)},	118	'-command' => sub{exit(0)},
119	);	119	);
120		120
121	my $menu_debug = $menu_bar->cascade(-label => "D~ebug");	121	my $menu_debug = $menu_bar->cascade(-label => "D~ebug");
122	$menu_debug->command('-label' => 'NC ~OSD Record (O)',	122	$menu_debug->command('-label' => 'NC ~OSD Record (O)',
123	'-command' => [\&DisplayHash, \%MkOsd, "NC OSD Record (O)", "Display Refresh Heartbeat"],	123	'-command' => [\&DisplayHash, \%MkOsd, "NC OSD Record (O)", "Display Refresh Heartbeat"],
124	);	124	);
125	$menu_debug->command('-label' => 'NC ~Target Record (s)',	125	$menu_debug->command('-label' => 'NC ~Target Record (s)',
126	'-command' => [\&DisplayHash, \%MkTarget, "NC Target Record (s)", "Display Refresh Heartbeat"],	126	'-command' => [\&DisplayHash, \%MkTarget, "NC Target Record (s)", "Display Refresh Heartbeat"],
127	);	127	);
128	$menu_debug->command('-label' => 'NC ~Debug Record (D)',	128	$menu_debug->command('-label' => 'NC ~Debug Record (D)',
129	'-command' => [\&DisplayHash, \%MkNcDebug, "NC Debug Record (D)", "Display Refresh Heartbeat"],	129	'-command' => [\&DisplayHash, \%MkNcDebug, "NC Debug Record (D)", "Display Refresh Heartbeat"],
130	);	130	);
131	$menu_debug->command('-label' => 'NC ~Other',	131	$menu_debug->command('-label' => 'NC ~Other',
132	'-command' => [\&DisplayHash, \%Mk, "NC Other", "Display Refresh Heartbeat"],	132	'-command' => [\&DisplayHash, \%Mk, "NC Other", "Display Refresh Heartbeat"],
133	);	133	);
134	$menu_debug->separator;	134	$menu_debug->separator;
135	$menu_debug->command('-label' => 'Tracking ~Antenna Debug Record',	135	$menu_debug->command('-label' => 'Tracking ~Antenna Debug Record',
136	'-command' => [\&DisplayHash, \%MkTrack, "Tracking Antenna Debug Record", "Display Refresh Heartbeat"],	136	'-command' => [\&DisplayHash, \%MkTrack, "Tracking Antenna Debug Record", "Display Refresh Heartbeat"],
137	);	137	);
138		138
139	my $menu_help = $menu_bar->cascade(-label => "~Help");	139	my $menu_help = $menu_bar->cascade(-label => "~Help");
140	$menu_help->command('-label' => 'Version',	140	$menu_help->command('-label' => 'Version',
141	'-command' => [\&DisplayHash, \%Version, "Version", "Display"],	141	'-command' => [\&DisplayHash, \%Version, "Version", "Display"],
142	);	142	);
143	$menu_help->separator;	143	$menu_help->separator;
144	$menu_help->command('-label' => 'About',	144	$menu_help->command('-label' => 'About',
145	'-command' => sub	145	'-command' => sub
146	{	146	{
147	my $License = <<EOF;	147	my $License = <<EOF;
148	Copyright (C) 2009 Rainer Walther (rainerwalther-mail\@web.de)	148	Copyright (C) 2009 Rainer Walther (rainerwalther-mail\@web.de)
149		149
150	Creative Commons Lizenz mit den Zusaetzen (by, nc, sa)	150	Creative Commons Lizenz mit den Zusaetzen (by, nc, sa)
151		151
152	Siehe LICENSE.TXT	152	Siehe LICENSE.TXT
153	EOF	153	EOF
154		154
155	my $DlgAbout = $frame_map->Dialog('-title' => 'About MK Mission Cockpit',	155	my $DlgAbout = $frame_map->Dialog('-title' => 'About MK Mission Cockpit',
156	'-text' => "$License",	156	'-text' => "$License",
157	'-buttons' => ['OK'],	157	'-buttons' => ['OK'],
158	'-bitmap' => 'info',	158	'-bitmap' => 'info',
159	);	159	);
160	$DlgAbout->Show;	160	$DlgAbout->Show;
161	});	161	});
162		162
163		163
164	# Main window Status line	164	# Main window Status line
165	$frame_status = $main->Frame( '-background' => 'lightgray',	165	$frame_status = $main->Frame( '-background' => 'lightgray',
166	) -> pack('-side' => 'bottom',	166	) -> pack('-side' => 'bottom',
167	'-anchor' => 'w',	167	'-anchor' => 'w',
168	'-fill' => 'none',	168	'-fill' => 'none',
169	'-expand' => 'y',	169	'-expand' => 'y',
170	);	170	);
171	$status_line = $frame_status->Label ('-text' => 'Status line',	171	$status_line = $frame_status->Label ('-text' => 'Status line',
172	) -> pack ('-side' => 'bottom',	172	) -> pack ('-side' => 'bottom',
173	);	173	);
174		174
175		175
176	#-----------------------------------------------------------------	176	#-----------------------------------------------------------------
177	# Frames	177	# Frames
178	#-----------------------------------------------------------------	178	#-----------------------------------------------------------------
179		179
180	#	180	#
181	# Frame: Map	181	# Frame: Map
182	#	182	#
183		183
184	$frame_map = $main->Frame( '-background' => 'lightgray',	184	$frame_map = $main->Frame( '-background' => 'lightgray',
185	'-relief' => 'sunken',	185	'-relief' => 'sunken',
186	'-borderwidth' => 5,	186	'-borderwidth' => 5,
187	) -> pack('-side' => 'top',	187	) -> pack('-side' => 'top',
188	'-fill' => 'x',	188	'-fill' => 'x',
189	);	189	);
190		190
191	# Map Überschrift	191	# Map Überschrift
192	$frame_map_top = $frame_map->Frame() -> pack( '-side' => 'top',	192	$frame_map_top = $frame_map->Frame() -> pack( '-side' => 'top',
193	'-expand' => 'x',	193	'-expand' => 'x',
194	'-anchor' => 'w',	194	'-anchor' => 'w',
195	);	195	);
196		196
197	$frame_map_top->Label ('-text' => "Karte: $Map{'Name'} ($Map{'File'})",	197	$frame_map_top->Label ('-text' => "Karte: $Map{'Name'} ($Map{'File'})",
198	'-background' => 'lightgray',	198	'-background' => 'lightgray',
199	'-relief' => 'flat',	199	'-relief' => 'flat',
200	) -> pack( '-side' => 'left' );	200	) -> pack( '-side' => 'left' );
201		201
202	# Map Statuszeile	202	# Map Statuszeile
203	$map_status = $frame_map->Frame( '-background' => 'lightgray',	203	$map_status = $frame_map->Frame( '-background' => 'lightgray',
204	) -> pack('-side' => 'bottom',	204	) -> pack('-side' => 'bottom',
205	'-anchor' => 'w',	205	'-anchor' => 'w',
206	'-fill' => 'none',	206	'-fill' => 'none',
207	'-expand' => 'y',	207	'-expand' => 'y',
208	);	208	);
209	$map_status_line = $map_status->Label ( '-text' => 'Statuszeile',	209	$map_status_line = $map_status->Label ( '-text' => 'Statuszeile',
210	'-background' => 'lightgray',	210	'-background' => 'lightgray',
211	) -> pack ('-side' => 'bottom',);	211	) -> pack ('-side' => 'bottom',);
212		212
213	# Map Canvas	213	# Map Canvas
214		214
215	# Canvas size	215	# Canvas size
216	$MapSizeX = $Map{'Size_X'};	216	$MapSizeX = $Map{'Size_X'};
217	$MapSizeY = $Map{'Size_Y'};	217	$MapSizeY = $Map{'Size_Y'};
218		218
219	$map_canvas = $frame_map->Canvas( '-width' => $MapSizeX,	219	$map_canvas = $frame_map->Canvas( '-width' => $MapSizeX,
220	'-height' => $MapSizeY,	220	'-height' => $MapSizeY,
221	'-cursor' => 'cross',	221	'-cursor' => 'cross',
222	) -> pack();	222	) -> pack();
223		223
224	# load Map photo	224	# load Map photo
225	$map_canvas->Photo( 'Map',	225	$map_canvas->Photo( 'Map',
226	'-file' => "$Cfg->{'map'}->{'MapDir'}/$Map{'File'}",	226	'-file' => "$Cfg->{'map'}->{'MapDir'}/$Map{'File'}",
227	);	227	);
228		228
229	$map_canvas->createImage( 0, 0,	229	$map_canvas->createImage( 0, 0,
230	'-tags' => 'Map',	230	'-tags' => 'Map',
231	'-anchor' => 'nw',	231	'-anchor' => 'nw',
232	'-image' => 'Map',	232	'-image' => 'Map',
233	);	233	);
234		234
235	# border polygon	235	# border polygon
236	$map_canvas->createPolygon( @Map{'Border'},	236	$map_canvas->createPolygon( @Map{'Border'},
237	'-tags' => 'Map-Border',	237	'-tags' => 'Map-Border',
238	'-fill' => '',	238	'-fill' => '',
239	'-outline' => $Cfg->{'mkcockpit'}->{'ColorAirfield'}, '-width' => 2,	239	'-outline' => $Cfg->{'mkcockpit'}->{'ColorAirfield'}, '-width' => 2,
240	);	240	);
241		241
242	# load Heartbeat icon	242	# load Heartbeat icon
243	$map_canvas->Photo( 'HeartbeatSmall',	243	$map_canvas->Photo( 'HeartbeatSmall',
244	'-file' => "$Cfg->{'mkcockpit'}->{'IconHeartSmall'}",	244	'-file' => "$Cfg->{'mkcockpit'}->{'IconHeartSmall'}",
245	);	245	);
246	$map_canvas->Photo( 'HeartbeatLarge',	246	$map_canvas->Photo( 'HeartbeatLarge',
247	'-file' => "$Cfg->{'mkcockpit'}->{'IconHeartLarge'}",	247	'-file' => "$Cfg->{'mkcockpit'}->{'IconHeartLarge'}",
248	);	248	);
249	$map_canvas->createImage( $MapSizeX/4, 10,	249	$map_canvas->createImage( $MapSizeX/4, 10,
250	'-tags' => 'Heartbeat',	250	'-tags' => 'Heartbeat',
251	'-anchor' => 'nw',	251	'-anchor' => 'nw',
252	'-image' => 'HeartbeatSmall',	252	'-image' => 'HeartbeatSmall',
253	);	253	);
254		254
255	# load Satellite icon	255	# load Satellite icon
256	$map_canvas->Photo( 'Satellite-Photo',	256	$map_canvas->Photo( 'Satellite-Photo',
257	'-file' => "$Cfg->{'mkcockpit'}->{'IconSatellite'}",	257	'-file' => "$Cfg->{'mkcockpit'}->{'IconSatellite'}",
258	);	258	);
259	$map_canvas->createImage($MapSizeX-190, -100, # hide photo	259	$map_canvas->createImage($MapSizeX-190, -100, # hide photo
260	'-tags' => 'Satellite',	260	'-tags' => 'Satellite',
261	'-anchor' => 'nw',	261	'-anchor' => 'nw',
262	'-image' => 'Satellite-Photo',	262	'-image' => 'Satellite-Photo',
263	);	263	);
264		264
265	# load Waypoint icon	265	# load Waypoint icon
266	$map_canvas->Photo( 'Waypoint-Photo',	266	$map_canvas->Photo( 'Waypoint-Photo',
267	'-file' => "$Cfg->{'mkcockpit'}->{'IconWaypoint'}",	267	'-file' => "$Cfg->{'mkcockpit'}->{'IconWaypoint'}",
268	);	268	);
269	# load Target icon	269	# load Target icon
270	$map_canvas->Photo( 'Target-Photo',	270	$map_canvas->Photo( 'Target-Photo',
271	'-file' => "$Cfg->{'mkcockpit'}->{'IconTarget'}",	271	'-file' => "$Cfg->{'mkcockpit'}->{'IconTarget'}",
272	);	272	);
273		273
274	$map_canvas->createImage(0, -100, # hide photo	274	$map_canvas->createImage(0, -100, # hide photo
275	'-tags' => 'Target',	275	'-tags' => 'Target',
276	'-anchor' => 'nw',	276	'-anchor' => 'nw',
277	'-image' => 'Target-Photo',	277	'-image' => 'Target-Photo',
278	);	278	);
279		279
280	# load Fox icon	280	# load Fox icon
281	$map_canvas->Photo( 'Fox-Photo',	281	$map_canvas->Photo( 'Fox-Photo',
282	'-file' => "$Cfg->{'mkcockpit'}->{'IconFox'}",	282	'-file' => "$Cfg->{'mkcockpit'}->{'IconFox'}",
283	);	283	);
284	$map_canvas->createImage($MapSizeX/2+50, $MapSizeY/2,	284	$map_canvas->createImage($MapSizeX/2+50, $MapSizeY/2,
285	'-tags' => 'Fox',	285	'-tags' => 'Fox',
286	'-anchor' => 'nw',	286	'-anchor' => 'nw',
287	'-image' => 'Fox-Photo',	287	'-image' => 'Fox-Photo',
288	);	288	);
289		289
290	# load WP-Player icons	290	# load WP-Player icons
291	$map_canvas->Photo( 'WpPlay-Foto', '-file' => "$Cfg->{'waypoint'}->{'IconPlay'}");	291	$map_canvas->Photo( 'WpPlay-Foto', '-file' => "$Cfg->{'waypoint'}->{'IconPlay'}");
292	$map_canvas->Photo( 'WpStop-Foto', '-file' => "$Cfg->{'waypoint'}->{'IconStop'}");	292	$map_canvas->Photo( 'WpStop-Foto', '-file' => "$Cfg->{'waypoint'}->{'IconStop'}");
293	$map_canvas->Photo( 'WpPause-Foto', '-file' => "$Cfg->{'waypoint'}->{'IconPause'}");	293	$map_canvas->Photo( 'WpPause-Foto', '-file' => "$Cfg->{'waypoint'}->{'IconPause'}");
294	$map_canvas->Photo( 'WpNext-Foto', '-file' => "$Cfg->{'waypoint'}->{'IconNext'}");	294	$map_canvas->Photo( 'WpNext-Foto', '-file' => "$Cfg->{'waypoint'}->{'IconNext'}");
295	$map_canvas->Photo( 'WpPrev-Foto', '-file' => "$Cfg->{'waypoint'}->{'IconPrev'}");	295	$map_canvas->Photo( 'WpPrev-Foto', '-file' => "$Cfg->{'waypoint'}->{'IconPrev'}");
296	$map_canvas->Photo( 'WpFirst-Foto', '-file' => "$Cfg->{'waypoint'}->{'IconFirst'}");	296	$map_canvas->Photo( 'WpFirst-Foto', '-file' => "$Cfg->{'waypoint'}->{'IconFirst'}");
297	$map_canvas->Photo( 'WpLast-Foto', '-file' => "$Cfg->{'waypoint'}->{'IconLast'}");	297	$map_canvas->Photo( 'WpLast-Foto', '-file' => "$Cfg->{'waypoint'}->{'IconLast'}");
298	$map_canvas->Photo( 'WpHome-Foto', '-file' => "$Cfg->{'waypoint'}->{'IconHome'}");	298	$map_canvas->Photo( 'WpHome-Foto', '-file' => "$Cfg->{'waypoint'}->{'IconHome'}");
299		299
300	$map_canvas->createImage($MapSizeX/2+100, $MapSizeY-48,	300	$map_canvas->createImage($MapSizeX/2+100, $MapSizeY-48,
301	'-tags' => 'Wp-PlayPause',	301	'-tags' => 'Wp-PlayPause',
302	'-anchor' => 'nw',	302	'-anchor' => 'nw',
303	'-image' => 'WpPlay-Foto',	303	'-image' => 'WpPlay-Foto',
304	);	304	);
305	$map_canvas->createImage($MapSizeX/2+150, $MapSizeY-48,	305	$map_canvas->createImage($MapSizeX/2+150, $MapSizeY-48,
306	'-tags' => 'Wp-Stop',	306	'-tags' => 'Wp-Stop',
307	'-anchor' => 'nw',	307	'-anchor' => 'nw',
308	'-image' => 'WpStop-Foto',	308	'-image' => 'WpStop-Foto',
309	);	309	);
310	$map_canvas->createImage($MapSizeX/2, $MapSizeY-48,	310	$map_canvas->createImage($MapSizeX/2, $MapSizeY-48,
311	'-tags' => 'Wp-Next',	311	'-tags' => 'Wp-Next',
312	'-anchor' => 'nw',	312	'-anchor' => 'nw',
313	'-image' => 'WpNext-Foto',	313	'-image' => 'WpNext-Foto',
314	);	314	);
315	$map_canvas->createImage($MapSizeX/2-50, $MapSizeY-48,	315	$map_canvas->createImage($MapSizeX/2-50, $MapSizeY-48,
316	'-tags' => 'Wp-Prev',	316	'-tags' => 'Wp-Prev',
317	'-anchor' => 'nw',	317	'-anchor' => 'nw',
318	'-image' => 'WpPrev-Foto',	318	'-image' => 'WpPrev-Foto',
319	);	319	);
320	$map_canvas->createImage($MapSizeX/2-100, $MapSizeY-48,	320	$map_canvas->createImage($MapSizeX/2-100, $MapSizeY-48,
321	'-tags' => 'Wp-First',	321	'-tags' => 'Wp-First',
322	'-anchor' => 'nw',	322	'-anchor' => 'nw',
323	'-image' => 'WpFirst-Foto',	323	'-image' => 'WpFirst-Foto',
324	);	324	);
325	$map_canvas->createImage($MapSizeX/2+50, $MapSizeY-48,	325	$map_canvas->createImage($MapSizeX/2+50, $MapSizeY-48,
326	'-tags' => 'Wp-Last',	326	'-tags' => 'Wp-Last',
327	'-anchor' => 'nw',	327	'-anchor' => 'nw',
328	'-image' => 'WpLast-Foto',	328	'-image' => 'WpLast-Foto',
329	);	329	);
330	$map_canvas->createImage($MapSizeX/2-150, $MapSizeY-48,	330	$map_canvas->createImage($MapSizeX/2-150, $MapSizeY-48,
331	'-tags' => 'Wp-Home',	331	'-tags' => 'Wp-Home',
332	'-anchor' => 'nw',	332	'-anchor' => 'nw',
333	'-image' => 'WpHome-Foto',	333	'-image' => 'WpHome-Foto',
334	);	334	);
335		335
336		336
337	# Balloon attached to Canvas	337	# Balloon attached to Canvas
338	$map_balloon = $frame_map->Balloon('-statusbar' => $status_line, );	338	$map_balloon = $frame_map->Balloon('-statusbar' => $status_line, );
339	$map_balloon->attach($map_canvas,	339	$map_balloon->attach($map_canvas,
340	'-balloonposition' => 'mouse',	340	'-balloonposition' => 'mouse',
341	'-state' => 'balloon',	341	'-state' => 'balloon',
342	'-msg' => { 'MK-Arrow' => "MikroKopter",	342	'-msg' => { 'MK-Arrow' => "MikroKopter",
343	'MK-Home-Line' => "Go Home",	343	'MK-Home-Line' => "Go Home",
344	'MK-Home-Dist' => "Distance to Home",	344	'MK-Home-Dist' => "Distance to Home",
345	'MK-Target-Line' => "This way to the target",	345	'MK-Target-Line' => "This way to the target",
346	'MK-Target-Dist' => "Distance to target",	346	'MK-Target-Dist' => "Distance to target",
347	'MK-Speed' => 'Velocity vector',	347	'MK-Speed' => 'Velocity vector',
348	'Map-Variometer' => 'Variometer',	348	'Map-Variometer' => 'Variometer',
349	'Map-Variometer-Pointer' => 'Variometer',	349	'Map-Variometer-Pointer' => 'Variometer',
350	'Map-Variometer-Skala' => 'Variometer',	350	'Map-Variometer-Skala' => 'Variometer',
351	'Fox' => 'Target for fox hunting',	351	'Fox' => 'Target for fox hunting',
352	'Heartbeat' => 'MK data activity',	352	'Heartbeat' => 'MK data activity',
353	'Satellite' => 'Good satellite reception',	353	'Satellite' => 'Good satellite reception',
354	'Waypoint' => 'Waypoint',	354	'Waypoint' => 'Waypoint',
355	'Map-Border' => 'Map border',	355	'Map-Border' => 'Map border',
356	'Waypoint-Connector' => 'Waypoint Connector',	356	'Waypoint-Connector' => 'Waypoint Connector',
357	'Wp-PlayPause' => 'Play/Pause',	357	'Wp-PlayPause' => 'Play/Pause',
358	'Wp-Stop' => 'Stop',	358	'Wp-Stop' => 'Stop',
359	'Wp-First' => 'Go to First Waypoint',	359	'Wp-First' => 'Go to First Waypoint',
360	'Wp-Last' => 'Go to Last Waypoint',	360	'Wp-Last' => 'Go to Last Waypoint',
361	'Wp-Next' => 'Go to Next Waypoint',	361	'Wp-Next' => 'Go to Next Waypoint',
362	'Wp-Prev' => 'Go to Previous Waypoint',	362	'Wp-Prev' => 'Go to Previous Waypoint',
363	'Wp-Home' => 'Go Home',	363	'Wp-Home' => 'Go Home',
364	},	364	},
365	);	365	);
366	#	366	#
367	# Mouse buttons	367	# Mouse buttons
368	#	368	#
369		369
370	# general Mouse button 1	370	# general Mouse button 1
371	$map_canvas->CanvasBind("<Button-1>", sub	371	$map_canvas->CanvasBind("<Button-1>", sub
372	{	372	{
373	# print coords in status line	373	# print coords in status line
374	my ($x, $y) = ($Tk::event->x, $Tk::event->y);	374	my ($x, $y) = ($Tk::event->x, $Tk::event->y);
375	my ($Lat, $Lon) = &MapXY2Gps($x, $y);	375	my ($Lat, $Lon) = &MapXY2Gps($x, $y);
376	$map_status_line->configure ('-text' => "Lat: $Lat Lon: $Lon x: $x y: $y");	376	$map_status_line->configure ('-text' => "Lat: $Lat Lon: $Lon x: $x y: $y");
377	});	377	});
378		378
379	# Mouse button 1 for Fox	379	# Mouse button 1 for Fox
380	my $FoxOldx = 0;	380	my $FoxOldx = 0;
381	my $FoxOldy = 0;	381	my $FoxOldy = 0;
382		382
383	# Pick Fox	383	# Pick Fox
384	$map_canvas->bind('Fox' => '<Button-1>' => sub	384	$map_canvas->bind('Fox' => '<Button-1>' => sub
385	{	385	{
386	# prepare to move Fox	386	# prepare to move Fox
387	my ($x, $y) = ($Tk::event->x, $Tk::event->y);	387	my ($x, $y) = ($Tk::event->x, $Tk::event->y);
388	$FoxOldx = $x;	388	$FoxOldx = $x;
389	$FoxOldy = $y;	389	$FoxOldy = $y;
390	$FoxTime = time;	390	$FoxTime = time;
391	});	391	});
392		392
393	# Move Fox	393	# Move Fox
394	$map_canvas->bind('Fox' => '<Button1-Motion>' => sub	394	$map_canvas->bind('Fox' => '<Button1-Motion>' => sub
395	{	395	{
396	my ($x, $y) = ($Tk::event->x, $Tk::event->y);	396	my ($x, $y) = ($Tk::event->x, $Tk::event->y);
397	my $id = $map_canvas->find('withtag', 'current');	397	my $id = $map_canvas->find('withtag', 'current');
398		398
399	$map_canvas->move($id => $x - $FoxOldx, $y - $FoxOldy);	399	$map_canvas->move($id => $x - $FoxOldx, $y - $FoxOldy);
400	$FoxOldx = $x;	400	$FoxOldx = $x;
401	$FoxOldy = $y;	401	$FoxOldy = $y;
402		402
403	if ( time > $FoxTime )	403	if ( time > $FoxTime )
404	{	404	{
405	# wenn in Bewegung Koordinaten nur 1/s senden	405	# wenn in Bewegung Koordinaten nur 1/s senden
406	my ($x0, $y0, $x1, $y1) = $map_canvas->bbox ($id);	406	my ($x0, $y0, $x1, $y1) = $map_canvas->bbox ($id);
407	$x = $x0 + ($x1 - $x0)/2;	407	$x = $x0 + ($x1 - $x0)/2;
408	$y = $y1;	408	$y = $y1;
409		409
410	my ($Lat, $Lon) = &MapXY2Gps($x, $y);	410	my ($Lat, $Lon) = &MapXY2Gps($x, $y);
411	&MkFlyTo ( '-lat' => $Lat,	411	&MkFlyTo ( '-lat' => $Lat,
412	'-lon' => $Lon,	412	'-lon' => $Lon,
413	'-mode' => "Target",	413	'-mode' => "Target",
414	);	414	);
415	$FoxTime = time;	415	$FoxTime = time;
416		416
417	$map_status_line->configure ('-text' => "Target coordinates sent -> Lat: $Lat Lon: $Lon x: $x y: $y");	417	$map_status_line->configure ('-text' => "Target coordinates sent -> Lat: $Lat Lon: $Lon x: $x y: $y");
418	}	418	}
419	});	419	});
420		420
421	# Release Fox	421	# Release Fox
422	$map_canvas->bind('Fox' => '<Button1-ButtonRelease>' => sub	422	$map_canvas->bind('Fox' => '<Button1-ButtonRelease>' => sub
423	{	423	{
424	my ($x, $y) = ($Tk::event->x, $Tk::event->y);	424	my ($x, $y) = ($Tk::event->x, $Tk::event->y);
425	my $id = $map_canvas->find('withtag', 'current');	425	my $id = $map_canvas->find('withtag', 'current');
426		426
427	my ($x0, $y0, $x1, $y1) = $map_canvas->bbox ($id);	427	my ($x0, $y0, $x1, $y1) = $map_canvas->bbox ($id);
428	$x = $x0 + ($x1 - $x0)/2;	428	$x = $x0 + ($x1 - $x0)/2;
429	$y = $y1;	429	$y = $y1;
430		430
431	my ($Lat, $Lon) = &MapXY2Gps($x, $y);	431	my ($Lat, $Lon) = &MapXY2Gps($x, $y);
432	&MkFlyTo ( '-lat' => $Lat,	432	&MkFlyTo ( '-lat' => $Lat,
433	'-lon' => $Lon,	433	'-lon' => $Lon,
434	'-mode' => "Target",	434	'-mode' => "Target",
435	);	435	);
436		436
437	# Show user that Waypoints in MK are cleared	437	# Show user that Waypoints in MK are cleared
438	$WaypointsModified = 1;	438	$WaypointsModified = 1;
439	&WpRedrawLines();	439	&WpRedrawLines();
440		440
441	$map_status_line->configure ('-text' => "Target coordinates sent -> Lat: $Lat Lon: $Lon x: $x y: $y");	441	$map_status_line->configure ('-text' => "Target coordinates sent -> Lat: $Lat Lon: $Lon x: $x y: $y");
442	});	442	});
443		443
444	# Pick Waypoint	444	# Pick Waypoint
445	$map_canvas->bind('Waypoint' => '<Button-1>' => sub	445	$map_canvas->bind('Waypoint' => '<Button-1>' => sub
446	{	446	{
447	# prepare to move	447	# prepare to move
448	my ($x, $y) = ($Tk::event->x, $Tk::event->y);	448	my ($x, $y) = ($Tk::event->x, $Tk::event->y);
449	$WpOldx = $x;	449	$WpOldx = $x;
450	$WpOldy = $y;	450	$WpOldy = $y;
451	});	451	});
452		452
453	# Move Waypoint	453	# Move Waypoint
454	$map_canvas->bind('Waypoint' => '<Button1-Motion>' => sub	454	$map_canvas->bind('Waypoint' => '<Button1-Motion>' => sub
455	{	455	{
456	my ($x, $y) = ($Tk::event->x, $Tk::event->y);	456	my ($x, $y) = ($Tk::event->x, $Tk::event->y);
457	my $id = $map_canvas->find('withtag', 'current');	457	my $id = $map_canvas->find('withtag', 'current');
458		458
459	# move icon and Wp-Number	459	# move icon and Wp-Number
460	my $WpIndex = &WpGetIndexFromId($id);	460	my $WpIndex = &WpGetIndexFromId($id);
461	if ( $WpIndex >= 0 )	461	if ( $WpIndex >= 0 )
462	{	462	{
463	my $Tag = $Waypoints[$WpIndex]{'Tag'};	463	my $Tag = $Waypoints[$WpIndex]{'Tag'};
464	$map_canvas->move($Tag => $x - $WpOldx, $y - $WpOldy);	464	$map_canvas->move($Tag => $x - $WpOldx, $y - $WpOldy);
465	}	465	}
466		466
467	$WpOldx = $x;	467	$WpOldx = $x;
468	$WpOldy = $y;	468	$WpOldy = $y;
469	});	469	});
470		470
471	# Release Wp	471	# Release Wp
472	$map_canvas->bind('Waypoint' => '<Button1-ButtonRelease>' => sub	472	$map_canvas->bind('Waypoint' => '<Button1-ButtonRelease>' => sub
473	{	473	{
474	my ($x, $y) = ($Tk::event->x, $Tk::event->y);	474	my ($x, $y) = ($Tk::event->x, $Tk::event->y);
475	my $id = $map_canvas->find('withtag', 'current');	475	my $id = $map_canvas->find('withtag', 'current');
476		476
477	# take coords from lower/middle icon position	477	# take coords from lower/middle icon position
478	my ($x0, $y0, $x1, $y1) = $map_canvas->bbox ($id);	478	my ($x0, $y0, $x1, $y1) = $map_canvas->bbox ($id);
479	$x = $x0 + ($x1 - $x0)/2;	479	$x = $x0 + ($x1 - $x0)/2;
480	$y = $y1;	480	$y = $y1;
481		481
482	# update Waypoint-Array	482	# update Waypoint-Array
483	my $WpIndex = &WpGetIndexFromId($id);	483	my $WpIndex = &WpGetIndexFromId($id);
484	if ( $WpIndex >= 0 )	484	if ( $WpIndex >= 0 )
485	{	485	{
486	# got it: set new coords	486	# got it: set new coords
487		487
488	my ($Lat, $Lon) = &MapXY2Gps($x, $y);	488	my ($Lat, $Lon) = &MapXY2Gps($x, $y);
489	my $Wp = $Waypoints[$WpIndex];	489	my $Wp = $Waypoints[$WpIndex];
490	$Wp->{'MapX'} = $x;	490	$Wp->{'MapX'} = $x;
491	$Wp->{'MapY'} = $y;	491	$Wp->{'MapY'} = $y;
492	$Wp->{'Pos_Lat'} = $Lat;	492	$Wp->{'Pos_Lat'} = $Lat;
493	$Wp->{'Pos_Lon'} = $Lon;	493	$Wp->{'Pos_Lon'} = $Lon;
494		494
495	# redraw connector-lines	495	# redraw connector-lines
496	&WpRedrawLines();	496	&WpRedrawLines();
497		497
498	# red connectors: Wp still have to be sent to MK	498	# red connectors: Wp still have to be sent to MK
499	$map_canvas->itemconfigure('Waypoint-Connector',	499	$map_canvas->itemconfigure('Waypoint-Connector',

Subversion Repositories Projects

(root)/MissionCockpit/branches/V0.2.0_EN/mkcockpit.pl @ 589 - Rev 475 → 476