fiji_ee_gui.pl

#-------------------------------------------------------------------------------
#  University of Applied Sciences Technikum Wien
#
#  Department of Embedded Systems
#  http://embsys.technikum-wien.at
#
#  Josef Ressel Center for Verification of Embedded Computing Systems
#  http://vecs.technikum-wien.at
#
#-------------------------------------------------------------------------------
#  Description:
#
#  FIJI Execution Engine GUI
#
#-------------------------------------------------------------------------------

## @file
# @brief FIJI Execution Engine (GUI)
## @file
# A TK GUI application to execute predefined, manually entered, and random tests

use strict;
use warnings;

use FindBin;
use lib "$FindBin::Bin";

use Log::Log4perl qw(get_logger);
use Tk;
use Tk::widgets qw(LabFrame Label Entry Button DialogBox FBox Checkbutton);
use Tk::FIJIUtils;
use Tk::FIJIModalDialog;
use Clone qw(clone);
use File::Spec;
use FIJI::Utils;
use threads;
use threads::shared;
use Thread::Queue;
use Data::Dumper;
use Socket;
use IO::Handle;
use Getopt::Long;

## @var USE_MENU defines control style of fiji_settings:
# 0 => classic, no menu GUI
# 1 => toplevel menu
# undef => classic+menu GUI
use constant USE_MENU => undef;

use FIJI qw(:default :fiji_dir :fiji_documentation_path);
use FIJI::Tests;
use FIJI::Downloader;
use Tk::FIJITestsViewer;
use Tk::FIJIUtils;

use constant TESTS_FILE_TYPES_CFG => [
    ['FIJI Tests', ['.tst']],
    ['All files', '*'],
];

use constant SETTINGS_FILE_TYPES_CFG => [
    ['FIJI Settings', ['.cfg', '*.ini']],
    ['All files', '*'],
];

use constant FILE_TYPES_CFG => [['FIJI Tests', ['.cfg', '*.ini']], ['All files', '*'],];
use constant FILE_TYPES_TB  => [['All files', '*'],];
use constant FILE_TYPES_GL  => [['VHDL Files', ['.vhd']],['All files', '*']];

use constant APPNAME => 'FIJI Execution Engine';

my $queue_to_worker = Thread::Queue->new();    # Queue from the GUI to the worker thread (transmitting workload)
my $queue_to_gui = Thread::Queue->new();    # Queue from worker to GUI (transmitting state, status message from the HW, and test patterns to re-enact the test run)
my $log_queue = Thread::Queue->new();    # Queue for communicating log messages to the GUI thread
my $worker_tid;
my $downloader;
my $unsaved_changes = 0;

my $current_dir = ".";

my $usage=<<"END_USAGE";
Usage: $0 [OPTION]
The graphical FIJI Tests Editor and Download Tool

Optional command-line arguments:
   -s, --settings-file=FILE    load the given settings file at startup
   -t, --tests-file=FILE       load the given test pattern file at startup
   -h, --help                  display this help and exit
END_USAGE

#** @function download_worker ()
# @brief Downloader worker thread for fiji_download_gui
#
# As Perl::Tk is not thread-safe, parallel GUI ops and Downloading tests is
# done via a master/worker pattern.
# The worker thread gets its work packages from a queue and answers via another.
# It implements a "Signal Handler" for SIGSTOP to abort a fault injection operation.
# Logging is done via a Queue so the Tk Part can display log messages in a
# Tk widget.
sub download_worker {
    eval {
        my $cont = 1;
        $SIG{'STOP'} = sub { $cont = 0; };
        my $logger = get_logger("");

        my $file_appender   = $Log::Log4perl::Logger::APPENDER_BY_NAME{'screen'};
        my $custom_appender = Log::Log4perl::Appender->new(
            "Log::Dispatch::QueueAppender",
            name      => "queueAppender",
            threshold => "info",
            queue     => $log_queue,
        );
        my $layout = $file_appender->{'layout'};
        $custom_appender->layout(clone($layout));
        $logger->add_appender($custom_appender);

        $queue_to_gui->enqueue({state => "starting"});

        # forever, get new workload
        while (defined(my $item = $queue_to_worker->dequeue())) {
            my $dl      = $item->{'downloader'};
            my $testref = {};
            $cont = 1;
            my $worker_msg;

            # download tests according to mode
            if ($item->{'mode'} eq "auto") {
                $worker_msg = $dl->download_auto(
                    \$testref,
                    $item->{'uart'},
                    sub {
                        my $worker_msg = shift;

                        # reply to GUI (intermediate)
                        $queue_to_gui->enqueue({state => "ongoing", rmsg => $worker_msg});
                        return $cont;
                    }
                );
            } elsif ($item->{'mode'} eq "random") {
                $worker_msg = $dl->download_random(
                    \$testref,
                    $item->{'uart'},
                    sub {
                        my $worker_msg = shift;

                        # reply to GUI (intermediate)
                        $queue_to_gui->enqueue({state => "ongoing", rmsg => $worker_msg});
                        return $cont;
                    }
                );
            } elsif ($item->{'mode'} eq "manual") {
                $worker_msg = $dl->download_test($item->{'test'}, $item->{'uart'});
            } elsif ($item->{'mode'} eq "dryrun") {
                $worker_msg = $dl->get_fic_status($item->{'uart'});
            }

            # reply to GUI (last message of current work package)
            $queue_to_gui->enqueue({state => "finished", rmsg => $worker_msg, testref => $testref});
        }
    };
    if ($@ ne "") {
        my $logger = get_logger("");
        $logger->error("Download worker exited unexpectedly: $@");
        # Return only first line of what eval returns to the GUI.
        # Usually this is something like:
        # "ERROR: can't load appenderclass 'Log::Dispatch::QueueAppender'"
        $queue_to_gui->enqueue({state => "dying", rmsg => (split /\n/, $@)[0]});
    }
}



sub _indicate_changes {
    my $logger = get_logger("");
    my $self   = shift;
    my $set    = shift;
    $unsaved_changes = $set;

    if ($unsaved_changes == 1) {
        $self->{'change_label'}->configure(-image => Tk::FIJIUtils::save_image($self->{'mw'}));
        $self->{'mw'}->configure(-title => "*" . APPNAME);
    } else {
        $self->{'change_label'}->configure(-image => Tk::FIJIUtils::dummy_image($self->{'mw'}));
        $self->{'mw'}->configure(-title => APPNAME);
    }
}



sub main {
    my $logger = get_logger("");
    my $name   = $0;
    my @ARGV   = @_;
    my $ret    = 0;
    $name =~ s/\.p[lm]//;
    $logger->debug("=== Starting new execution of $name ===");
    $logger->debug(sprintf("%d argument(s)%s", scalar(@_), scalar(@_) > 0 ? ": @_" : ""));

    my ($settings_filename, $tests_filename, $help);

    my $parse = GetOptions("settings-file=s" => \$settings_filename,
                           "tests-file=s"    => \$tests_filename,
                           "help"            => \$help);

    if (!$parse) {
        print STDERR $usage;
        return -1;
    }
    if (defined $help) {
        print STDOUT $usage;
        return 0;
    }

    my %hash;
    my $self = bless(\%hash);

    my $libdir = File::Spec->catdir(FIJI_DIR, "media");
    my $ugdir = File::Spec->catdir(FIJI_DIR, "docs", "userguide");

    my $tests_ini_name;
    $self->{'tests_ini_name'} = \$tests_ini_name;
    my $settings_ini_name;
    $self->{'settings_ini_name'} = \$settings_ini_name;

    $worker_tid = threads->create('download_worker');

    #
    # Build GUI
    #
    # Assigning $0 sets a "prettier" program title in Gnome's taskbar
    # Must not contain spaces (duh)
    $0 = (APPNAME =~ s/\s+/\-/rg);
    my $mw = MainWindow->new(-title => APPNAME);
    $self->{'mw'} = $mw;
    $mw->appname(APPNAME);
    $mw->withdraw();
    Tk::FIJIUtils::set_icon($mw);

    ### Load settings

    if (defined $settings_filename && (-e $settings_filename)) {
        my $filename = $settings_filename;
        my ($tmp_settings, $warn) = FIJI::Settings->new('setup', $filename);
        if (defined($warn)) {
            my $msg = "settings file $filename could not be loaded correctly: $tmp_settings";
            $logger->error($msg);
            my $d = $self->{'mw'}->FIJIModalDialog(-image     => (!defined($tmp_settings) ? Tk::FIJIUtils::error_image($self->{'mw'}) : Tk::FIJIUtils::alert_image($self->{'mw'})),
                                                   -wraplength => "200",
                                                   -text      => $warn,
                                                   -title     => 'Open FIJI Settings failed!',
                                                   -buttons   => ["OK"]);
            $d->Show();
            if (!defined($tmp_settings)) {
                $ret = 1;
                goto bailout;
            }
        }
        $self->{'settings'} = $tmp_settings;
        ${$self->{'settings_ini_name'}} = $filename;
        $current_dir = _setdir($filename);
    } else {
        ${$self->{'settings_ini_name'}} = $self->_load_settings_prompt($mw);
    }

    if (!defined ${$self->{'settings_ini_name'}}) {
        $logger->error("No settings file chosen");
        $ret = 1;
        goto bailout;
    }

    if (defined $tests_filename) {
        my $filename = $tests_filename;
        my $fr       = $mw;
        if (-e $filename) {
            # the mode 'GUI' is not defined in any ->phases_opt lists in TESTCONSTMAP and TESTPATMAP, thus all possible parameters have to be present.
            my $tmp_tests = FIJI::Tests->new('GUI', $self->{'settings'}->{'design'}->{'CFGS_PER_MSG'}, $self->{'settings'}->{'design'}->{'FIU_NUM'}, $filename,);
            if (!ref($tmp_tests)) {
                my $msg = "Tests file $filename could not be loaded correctly: $tmp_tests";
                $logger->error($msg);
                my $d = $self->{'mw'}->FIJIModalDialog(-image     => Tk::FIJIUtils::error_image($self->{'mw'}),
                                                       -wraplength => "200",
                                                       -text      => $msg,
                                                       -title     => 'Open FIJI Tests failed!',
                                                       -buttons   => ["OK"]);
                $d->Show();
                $ret = 1;
                goto bailout;
            }
            $self->{'tests'} = $tmp_tests;
        } else {
            # the mode 'GUI' is not defined in any ->phases_opt lists in TESTCONSTMAP and TESTPATMAP, thus all possible parameters have to be present.
            $self->{'tests'} = FIJI::Tests->new('GUI', $self->{'settings'}->{'design'}->{'CFGS_PER_MSG'}, $self->{'settings'}->{'design'}->{'FIU_NUM'}, undef, undef, 1);
            $self->{'tests'}->save($filename);
        }
        ${$self->{'tests_ini_name'}} = $filename;
        $current_dir = _setdir($filename);
    } else {
        # the mode 'GUI' is not defined in any ->phases_opt lists in TESTCONSTMAP and TESTPATMAP, thus all possible parameters have to be present.
        $self->{'tests'} = FIJI::Tests->new('GUI', $self->{'settings'}->{'design'}->{'CFGS_PER_MSG'}, $self->{'settings'}->{'design'}->{'FIU_NUM'}, undef, undef, 1);
        ${$self->{'tests_ini_name'}} = undef;
    }

    $downloader = FIJI::Downloader->new(undef,undef,$self->{'tests'}, undef, $self->{'settings'});
    $self->{'ctrl'} = _ctrl_frame($self, $mw);

    if (!defined USE_MENU || USE_MENU == 1) {
        $self->{'menu'} = $self->_menu($mw);
    }

    $mw->toplevel()->bind('<Control-o>'       => sub { $self->_open_tests_file; });
    $mw->toplevel()->bind("<Control-s>"       => sub { $self->_save; });
    $mw->toplevel()->bind("<Control-t>"       => sub { $self->_export_test; });
    $mw->toplevel()->bind("<Control-r>"       => sub { $self->_export_rtl_sim; });
    $mw->toplevel()->bind("<Control-g>"       => sub { $self->_export_gate_level_sim; });
    $mw->toplevel()->bind("<Control-Shift-S>" => sub { $self->_save_as; });
    $mw->toplevel()->bind("<Control-q>"       => sub { $self->_onexit(); });
    $mw->toplevel()->bind("<F1>"              => sub { Tk::FIJIUtils::show_documentation($mw); });

    $self->{'documentation_path'} = File::Spec->catfile($ugdir, 'fiji_user_guide.pdf');
    $self->{'FIJITestsViewer'} = $mw->FIJITestsViewer(
        -changes_callback => sub { my $value = shift; _indicate_changes($self, $value) },
        -test_callback    => sub { my $value = shift; $self->{'export_menuentry'}->configure(-state => ($value > 0) ? "normal" : "disabled")},
        -mw               => $self->{'mw'},
        -tests            => $self->{'tests'},
        -settings         => $self->{'settings'},
        -worker           => $worker_tid,
        -queue_to_worker  => $queue_to_worker,
        -queue_from_worker => $queue_to_gui,
        -log_queue         => $log_queue,
      )->pack(
        '-fill'   => 'both',
        '-expand' => 1
      );

    $mw->protocol('WM_DELETE_WINDOW' => [\&_onexit, $self]);

    $mw->deiconify();
    $mw->raise();
    $mw->update();

    # The download_helper will notify the GUI at startup of its status
    # by sending a message with 'state' set to either 'starting' or 'dying'
    # The event handler below will kill the main window in case something bad happend.
    $mw->afterIdle(sub {
        my $worker_msg = $self->{'FIJITestsViewer'}->{'queue_from_worker'}->dequeue();
        if ($worker_msg->{'state'} eq "dying") {
            my $d = $self->{'mw'}->FIJIModalDialog(-image     => Tk::FIJIUtils::error_image($self->{'mw'}),
                                                   -wraplength => "400",
                                                   -text      => $worker_msg->{'rmsg'},
                                                   -title     => 'Starting the download worker thread failed!',
                                                   -buttons   => ["OK"]);
            $d->Show();
            $self->{'FIJITestsViewer'}->{'mw'}->destroy();
            $ret = 1;
        }
    });

    MainLoop;

  bailout:
    $self->_cleanup();

    $logger->trace("=== Stopping execution ===");
    return $ret;
}

sub _menu {
    my ($self, $mw) = @_;

    my $menubar = $self->{'menu'} = $mw->Menu(-relief => "groove");

    my $tests  = $menubar->cascade(-label => '~Tests', -tearoff => 0);
    my $export = $menubar->cascade(-label => '~Export', -tearoff => 0, -state=>"disabled");
    my $help   = $menubar->cascade(-label => '~Help',  -tearoff => 0);

    $self->{'export_menuentry'} = $export;

    $tests->separator;
    $tests->command(
        -label       => 'Open',
        -accelerator => 'Ctrl-o',
        -underline   => 0,
        -command     => [\&_open_tests_file, $self],
    );
    $tests->separator;
    $tests->command(
        -label       => 'Save',
        -accelerator => 'Ctrl-s',
        -underline   => 0,
        -command     => [\&_save, $self],
    );
    $tests->command(
        -label       => 'Save As ...',
        -accelerator => 'Ctrl-Shift-s',
        -underline   => 1,
        -command     => [\&_save_as, $self],
    );

    $export->separator;
    $export->command(
        -label       => 'As Test Configuration',
        -accelerator => 'Ctrl+t',
        -underline   => '0',
        -command     => [\&_export_test, $self],
    );
    $export->command(
        -label       => 'As RTL simulation template',
        -accelerator => 'Ctrl+r',
        -underline   => '0',
        -command     => [\&_export_rtl_sim, $self],
    );
    $export->command(
        -label       => 'As VHDL architecture for gate-level simulation',
        -accelerator => 'Ctrl+r',
        -underline   => '0',
        -command     => [\&_export_gate_level_sim, $self],
    );

    $help->separator;
    $help->command(
        -label       => 'Open Documentation',
        -accelerator => 'F1',
        -underline   => 0,
        -command     => [\&Tk::FIJIUtils::show_documentation, $mw],
    );
    $help->separator;
    $help->command(
        -label     => 'About',
        -underline => 0,
        -command   => [\&Tk::FIJIUtils::show_about, $mw],
    );
    $mw->configure(-menu => $menubar);
}


sub _export_test {
    my $logger = get_logger("");
    my $self = shift;
    my $last_test_ref = $self->{'FIJITestsViewer'}->get_last_test();
    return if (!defined $last_test_ref);
    my $name;
    my $rv;
    do {
        $name = $self->{'mw'}->FBox(-title=> "Export last test run as test configuration...", -type => "save", -filetypes => TESTS_FILE_TYPES_CFG)->Show;
        if (defined $name) {
            $rv = $last_test_ref->save($name) if defined $name;
            if(defined $rv) {
                $logger->error($rv);

                my $d = $self->{'mw'}->FIJIModalDialog(-image       => Tk::FIJIUtils::error_image($self->{'mw'}),
                                                       -text        => $rv,
                                                       -title       => "Error saving tests.",
                                                       -buttons     => [qw/OK/]);
                $d->Show();
                return;
            }
        }
    } while (defined $name && defined $rv);
}

sub _export_gate_level_sim {
    my $logger = get_logger("");
    my $self = shift;
    my $last_test_ref = $self->{'FIJITestsViewer'}->get_last_test();
    return if (!defined $last_test_ref);
    my $name;
    my $rv;
    do {
        $name = $self->{'mw'}->FBox(-title=> "Export FIJI simulation model for gate-level simulation...", -type => "save", -filetypes => FILE_TYPES_GL)->Show;
        if (defined $name) {
            $rv = $last_test_ref->export_gate_level($name,$self->{'FIJITestsViewer'}->{'settings'});
            if(defined $rv) {
                $logger->error($rv);
                my $d = $self->{'mw'}->FIJIModalDialog(-image       => Tk::FIJIUtils::error_image($self->{'mw'}),
                                                       -text        => $rv,
                                                       -title       => "Error FIJI simulation model for gate-level simulation.",
                                                       -buttons     => [qw/OK/]);
                $d->Show();
                return;
            }
        }
    } while (defined $name && defined $rv);
}

sub _export_rtl_sim {
    my $logger = get_logger("");
    my $self = shift;
    my $last_test_ref = $self->{'FIJITestsViewer'}->get_last_test();;
    return if (!defined $last_test_ref);
    my $name;
    my $rv;
    do {
        $name = $self->{'mw'}->FBox(-title=> "Export RTL simulation templates... (basename)", -type => "save", -filetypes => FILE_TYPES_TB)->Show;
        if (defined $name) {
            $rv = $last_test_ref->export_tb($name,$self->{'FIJITestsViewer'}->{'settings'});
            if(defined $rv) {
                $logger->error($rv);
                my $d = $self->{'mw'}->FIJIModalDialog(-image       => Tk::FIJIUtils::error_image($self->{'mw'}),
                                                       -text        => $rv,
                                                       -title       => "Error saving RTL simulation templates.",
                                                       -buttons     => [qw/OK/]);
                $d->Show();
                return;
            }
        }
    } while (defined $name && defined $rv);
}

sub _setdir {
    my $filename = shift;
    my ($volume,$directories,$file) = File::Spec->splitpath($filename);
    return File::Spec->catpath($volume, $directories, "");
}

sub _load_settings_prompt {
    my $logger = get_logger("");
    my ($self, $fr) = @_;

    my $gcfg_lbl;
    my $gcfg_btn_open;
    my $gcfg_entry;

    my $tmp_settings;
    my $filename;

    while (!ref($tmp_settings)) {
        my $fb = $fr->FBox(
            -type        => 'open',
            -title       => 'Open FIJI Configuration file',
            -filetypes   => SETTINGS_FILE_TYPES_CFG,
            -initialdir  => $current_dir,
            -initialfile => 'fiji.cfg'
        );
        Tk::FIJIUtils::set_icon($fb);
        $filename = $fb->Show();

        if (!defined($filename)) {
            $logger->debug("User aborted open configuration action");
            return;
        }
        $current_dir = _setdir($filename);

        $tmp_settings = (defined $self->{'settings'}) ? \%{Clone::clone($self->{'settings'})} : undef;
        my $warn;
        ($tmp_settings, $warn) = FIJI::Settings->new('download', $filename, $tmp_settings);
        if (defined($warn)) {
            my $msg = "settings file $filename could not be loaded correctly: $warn";
            $logger->error($msg);
            my $d = $self->{'mw'}->FIJIModalDialog(-image     => (!defined($tmp_settings) ? Tk::FIJIUtils::error_image($self->{'mw'}) : Tk::FIJIUtils::alert_image($self->{'mw'})),
                                                   -wraplength => "200",
                                                   -text      => $warn,
                                                   -title     => 'Open FIJI Settings failed!',
                                                   -buttons   => ["OK"]);
            $d->Show();
        }
    }

    $self->{'settings'} = $tmp_settings;
    return $filename;
}

sub _ctrl_frame {
    my ($self, $fr) = @_;
    my $fr_ctrl = $fr->LabFrame(
        -label     => "Control",
        -labelside => "acrosstop"
      )->pack(
        -side   => 'top',
        -anchor => 'w',
        -fill   => 'x',

        # -expand => 1
      );

    my $fiji_cfg_lbl;
    my $fiji_cfg_entry;
    my $cfg_lbl;
    my $chng_lbl;
    my $cfg_btn_open;
    my $cfg_btn_save;
    my $cfg_btn_save_as;
    my $cfg_entry;

    $fiji_cfg_lbl = $fr_ctrl->Label(
        -text    => 'FIJI Configuration file',
        -justify => 'left',
    )->grid(-row => 0, -column => 0, -sticky => "e");

    $fiji_cfg_entry = $fr_ctrl->Entry(
        -text  => ${$self->{'settings_ini_name'}},
        -state => 'readonly',
    )->grid(-row => 0, -column => 2, -columnspan => 4, -sticky => "ew");

    $cfg_lbl = $fr_ctrl->Label(
        -text    => 'FIJI Tests file',
        -justify => 'left',
    )->grid(-row => 1, -column => 0, -sticky => "e");

    $self->{'change_label'} = $chng_lbl = $fr_ctrl->Label(
        -image => Tk::FIJIUtils::dummy_image($self->{'mw'}),
    )->grid(-row => 1, -column => 1, -sticky => "we");

    my $b = $fr_ctrl->Balloon();
    $b->attach($chng_lbl, -postcommand => sub { return $unsaved_changes == 1 }, -msg => "Unsaved changes");

    if (!defined USE_MENU || USE_MENU == 0) {
        $cfg_btn_open = $fr_ctrl->Button(
            -text    => 'Open',
            -command => [\&_open_tests_file, $self],
        )->grid(-row => 1, -column => 2, -sticky => "ew");
        $cfg_btn_open->focus();

        $cfg_btn_save = $fr_ctrl->Button(
            -text    => 'Save',
            -command => [\&_save, $self],

            # sub {
            # my $state = defined($filename) ? 'normal' : 'disabled';
            # $cfg_btn_open->configure(-state => $state);
            # $cfg_btn_save->configure(-state => $state);
            # },
        )->grid(-row => 1, -column => 3, -sticky => "ew");
        $cfg_btn_save_as = $fr_ctrl->Button(
            -text    => 'Save as',
            -command => [\&_save_as, $self],
        )->grid(-row => 1, -column => 4, -sticky => "ew");
    }

    $cfg_entry = $fr_ctrl->Entry(
        -textvariable       => $self->{'tests_ini_name'},
        -state              => 'disabled',
        -disabledforeground => 'black',
        -takefocus          => 0,                           # default for disabled
    )->grid(-row => 1, -column => 5, -sticky => "ew");
    $fr_ctrl->gridColumnconfigure(5, -weight => 1);

    return $fr_ctrl;
}

sub _open_tests_file {
    my $logger = get_logger("");
    my $self   = shift;

    my $fb = $self->{'mw'}->FBox(
        -type        => 'open',
        -title       => 'Open FIJI Tests file',
        -filetypes   => TESTS_FILE_TYPES_CFG,
        -initialdir  => $current_dir,
        -initialfile => 'fiji.tst'
    );
    Tk::FIJIUtils::set_icon($fb);
    my $filename = $fb->Show();

    if (!defined($filename)) {
        $logger->debug("User aborted open configuration action");
        return;
    }
    $current_dir = _setdir($filename);
    my $tmp_tests = (defined $self->{'tests'}) ? \%{Clone::clone($self->{'tests'})} : undef;
    $tmp_tests = FIJI::Tests->new('GUI', $self->{'settings'}->{'design'}->{'CFGS_PER_MSG'}, $self->{'settings'}->{'design'}->{'FIU_NUM'}, $filename, $tmp_tests);
    if (!ref($tmp_tests)) {
        my $msg = "tests file $filename could not be loaded correctly: $tmp_tests";
        $logger->error($msg);
        my $d = $self->{'mw'}->FIJIModalDialog(-image     => Tk::FIJIUtils::error_image($self->{'mw'}),
                                               -wraplength => "200",
                                               -text      => $msg,
                                               -title     => 'Open FIJI Tests failed!',
                                               -buttons   => ["OK"]);
        $d->Show();
        return;
    }
    if (!defined($self->{'FIJITestsViewer'}->configure(-tests => $tmp_tests))) {
        my $msg = "Could not update GUI correctly with new tests.";
        $logger->error($msg);
        my $d = $self->{'mw'}->FIJIModalDialog(-image     => Tk::FIJIUtils::error_image($self->{'mw'}),
                                               -wraplength => "200",
                                               -text      => $msg,
                                               -title     => 'Open FIJI Tests failed!',
                                               -buttons   => ["OK"]);
        $d->Show();
        return;
    }
    $self->{'tests'} = $tmp_tests;
    ${$self->{'tests_ini_name'}} = $filename;
    $downloader = FIJI::Downloader->new(undef, undef, $self->{'tests'}, undef, $self->{'settings'});
}

sub _overwrite_existing_file ($) {
    my ($self, $filename) = @_;
    my $logger = get_logger("");
    if (!-e $filename) {
        return 1;
    }
    my $d = $self->{'mw'}->FIJIModalDialog(-title     => 'Really overwrite?',
                                           -image     => Tk::FIJIUtils::alert_image($self->{'mw'}),
                                           -text      => "File \"$filename\" already exists.\nDo you want to overwrite it?",
                                           -buttons   => ["~Yes", "~No"]);
    my $reply = $d->Show();
    return (defined $reply && lc($reply) eq 'yes');
}

sub _save_file {
    my ($self, $filename) = @_;
    my $logger = get_logger("");
    if (!$self->_overwrite_existing_file($filename)) {
        return;
    }
    my $err = $self->{'tests'}->save($filename);
    if (defined($err)) {
        my $msg = "Saving to file $filename failed!\n$err";
        $logger->error($msg);
        my $d = $self->{'mw'}->FIJIModalDialog(-image       => Tk::FIJIUtils::error_image($self->{'mw'}),
                                               -text        => $msg,
                                               -title       => 'Save failed!',
                                               -buttons     => ["OK"]);
        $d->Show();
        return;
    }
    ${$self->{'tests_ini_name'}} = $filename;

    $self->{'FIJITestsViewer'}->set_state_as_original();

    $logger->info("Successfully saved to file $filename.");
}

sub _save {
    my ($self) = @_;
    if (!defined(${$self->{'tests_ini_name'}})) {
        return $self->_save_as();
    } else {
        return $self->_save_file(${$self->{'tests_ini_name'}});
    }
}

sub _save_as {
    my ($self) = @_;
    my $fb = $self->{'mw'}->FBox(
        -type             => 'save',
        -title            => 'Save FIJI Tests file as...',
        -defaultextension => 'cfg',
        -filetypes        => TESTS_FILE_TYPES_CFG,
        -initialdir       => $current_dir,
        -initialfile      => 'fiji.tst',
        -force            => 1, # prevent FBox's "overwrite?" dialog
                                #    because we have our own check and a nicer dialog
                                #    AND we want to prevent showing the dialog twice
    );
    Tk::FIJIUtils::set_icon($fb);
    my $filename = $fb->Show();

    if (!defined($filename)) {
        return;
    }
    $current_dir = _setdir($filename);
    return $self->_save_file($filename);
}

sub _onexit {
    my $logger = get_logger("");
    my ($self) = @_;

    return if (defined $self->{'already_clicked'} && $self->{'already_clicked'} == 1);
    $self->{'already_clicked'} = 1;

    my $response;
    if ($unsaved_changes == 1) {
        $logger->debug("Settings changed. Asking to save.");
        my $d = $self->{'mw'}->FIJIModalDialog(-image       => Tk::FIJIUtils::alert_image($self->{'mw'}),
                                               -text        => "Unsaved changes.\nDo you really want to quit?",
                                               -wraplength  => 350,
                                               -title       => 'Really quit?',
                                               -buttons     => ["~Save", "~Cancel", "~Quit"]);
        $response = $d->Show();
        $self->{'already_clicked'} = 0;

        # use _save_as to give the user the chance to save under a different name
        $self->_save_as if (defined $response && $response eq "Save");

        if (!defined $response || $response ne "Cancel") {
            goto finish;
        }
    } else {
        goto finish;
    }
    return;

finish:
    $self->{'mw'}->destroy();
    return;
}

sub _cleanup {
    my $self = shift;
    $self->{'mw'}->destroy() if Exists($self->{'mw'});

    # End the queue(s) to signal other threads to stop
    # There is a bug in 804.031 (and below?) that sometimes provokes
    # segfaults with this procedure, cf. https://rt.cpan.org/Public/Bug/Display.html?id=89621
    $queue_to_worker->end();
    $queue_to_gui->end();
    $log_queue->end();
    $worker_tid->join();
}

my $log_conf = File::Spec->catfile($FindBin::Bin, 'logger.conf');
Log::Log4perl::init_and_watch($log_conf, 'HUP');
exit main(@ARGV);