#! /usr/bin/perl -w

#

# Copyright (C) 2008-2015 Alexis Bienvenue <paamc@passoire.fr>

#

# This file is part of Auto-Multiple-Choice

#

# Auto-Multiple-Choice is free software: you can redistribute it

# and/or modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation, either version 2 of

# the License, or (at your option) any later version.

#

# Auto-Multiple-Choice is distributed in the hope that it will be

# useful, but WITHOUT ANY WARRANTY; without even the implied warranty

# of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

# General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with Auto-Multiple-Choice.  If not, see

# <http://www.gnu.org/licenses/>.

use Getopt::Long;

use Gtk2 -init;

use Glib::Object::Introspection;

use XML::Simple;

use IO::File;

use IO::Select;

use POSIX qw/strftime/;

use Time::Local;

use Cwd;

use File::Spec::Functions qw/splitpath catpath splitdir catdir catfile rel2abs tmpdir/;

use File::Temp qw/ tempfile tempdir /;

use File::Copy;

use File::Path qw/remove_tree/;

use File::Find;

use Archive::Tar;

use Archive::Tar::File;

use Encode;

use Unicode::Normalize;

use I18N::Langinfo qw(langinfo CODESET);

use Locale::Language;

use Text::ParseWords;

use Module::Load;

use Module::Load::Conditional qw/check_install/;

use AMC::Path;

use AMC::Basic;

use AMC::State;

use AMC::Data;

use AMC::DataModule::capture ':zone';

use AMC::DataModule::report ':const';

use AMC::Scoring;

use AMC::Gui::Prefs;

use AMC::Gui::Manuel;

use AMC::Gui::Association;

use AMC::Gui::Commande;

use AMC::Gui::Notes;

use AMC::Gui::Zooms;

use AMC::FileMonitor;

use AMC::Gui::WindowSize;

use Data::Dumper;

use constant {

    DOC_TITRE => 0,

    DOC_MAJ => 1,

    MEP_PAGE => 0,

    MEP_ID => 1,

    MEP_MAJ => 2,

    DIAG_ID => 0,

    DIAG_ID_BACK => 1,

    DIAG_MAJ => 2,

    DIAG_EQM => 3,

    DIAG_EQM_BACK => 4,

    DIAG_DELTA => 5,

    DIAG_DELTA_BACK => 6,

    DIAG_ID_STUDENT => 7,

    DIAG_ID_PAGE => 8,

    DIAG_ID_COPY => 9,

    INCONNU_FILE => 0,

    INCONNU_SCAN => 1,

    INCONNU_TIME => 2,

    INCONNU_TIME_N => 3,

    INCONNU_PREPROC => 4,

    PROJ_NOM => 0,

    PROJ_ICO => 1,

    MODEL_NOM => 0,

    MODEL_PATH => 1,

    MODEL_DESC => 2,

    COPIE_N => 0,

    TEMPLATE_FILES_PATH => 0,

    TEMPLATE_FILES_FILE => 1,

    EMAILS_SC => 0,

    EMAILS_NAME => 1,

    EMAILS_EMAIL => 2,

    EMAILS_ID => 3,

    ATTACHMENTS_FILE => 0,

    ATTACHMENTS_NAME => 1,

    ATTACHMENTS_FOREGROUND => 2,

  };

my $libnotify_error='';

Gtk2::IconTheme->get_default->prepend_search_path(amc_specdir('icons'));

Gtk2::Window->set_default_icon_list(map { Gtk2::IconTheme->get_default->load_icon("auto-multiple-choice",$_,"force-svg") } (8,16,32,48,64,128));

use_gettext;

use_amc_plugins();

POSIX::setlocale(&POSIX::LC_NUMERIC,"C");

my $debug=0;

my $debug_file='';

my $profile='';

my $project_dir='';

GetOptions("debug!"=>\$debug,

	   "debug-file=s"=>\$debug_file,

	   "profile=s"=>\$profile,

	   "p=s"=>\$project_dir,

	   );

$project_dir=Cwd::realpath($project_dir) if($project_dir);

sub set_debug_mode {

  my ($debug)=@_;

  set_debug($debug);

  if($debug) {

    my $date=strftime("%c",localtime());

    debug ('#' x 40);

    debug "# DEBUG - $date";

    debug ('#' x 40);

    debug "GUI module is located at ".__FILE__;

  }

}

if($debug_file) {

    $debug=$debug_file;

}

if($debug) {

    set_debug_mode($debug);

    print "DEBUG ==> ".AMC::Basic::debug_file()."\n";

}

debug_pm_version("Gtk2");

my %w=();

my $glade_base=__FILE__;

$glade_base =~ s/\.p[ml]$/-/i;

my $home_dir=Glib::get_home_dir();

my $shortcuts=AMC::Path::new(home_dir=>$home_dir);

my $prefs=AMC::Gui::Prefs::new(shortcuts=>$shortcuts,alternate_w=>\%w);

my $o_file='';

my $o_dir=amc_user_confdir();

my $state_file="$o_dir/state.xml";

my $monitor=AMC::FileMonitor->new();

# Gets system encoding

my $encodage_systeme=langinfo(CODESET());

$encodage_systeme='UTF-8' if(!$encodage_systeme);

sub hex_color {

    my $s=shift;

    return(Gtk2::Gdk::Color->parse($s)->to_string());

}

# Default general options, to be used when not set in the main options

# file

my %o_defaut=('pdf_viewer'=>['commande',

			     'evince','acroread','gpdf','okular','xpdf',

			     ],

	      'img_viewer'=>['commande',

			     'eog','ristretto','gpicview','mirage','gwenview',

			     ],

	      'csv_viewer'=>['commande',

			     'gnumeric','kspread','libreoffice','localc','oocalc',

			     ],

	      'ods_viewer'=>['commande',

			     'libreoffice','localc','oocalc',

			     ],

	      'xml_viewer'=>['commande',

			     'gedit','kedit','kwrite','mousepad','leafpad',

			     ],

	      'tex_editor'=>['commande',

			     'texmaker','kile','gummi','emacs','gedit','kedit','kwrite','mousepad','leafpad',

			     ],

	      'txt_editor'=>['commande',

			     'gedit','kedit','kwrite','mousepad','emacs','leafpad',

			     ],

	      'html_browser'=>['commande',

			       'sensible-browser %u',

			       'firefox %u',

			       'galeon %u',

			       'konqueror %u',

			       'dillo %u',

			       'chromium %u',

			       ],

	      'dir_opener'=>['commande',

			     'nautilus --no-desktop file://%d',

			     'pcmanfm %d',

			     'Thunar %d',

			     'konqueror file://%d',

			     'dolphin %d',

			     ],

	      'print_command_pdf'=>['commande',

				    'cupsdoprint %f','lpr %f',

				    ],

	      'print_extract_with'=>'pdftk',

# TRANSLATORS: directory name for projects. This directory will be created (if needed) in the home directory of the user. Please use only alphanumeric characters, and - or _. No accentuated characters.

	      'rep_projets'=>$home_dir.'/'.__"MC-Projects",

	      'projects_home'=>$home_dir.'/'.__"MC-Projects",

	      'rep_modeles'=>$o_dir."/Models",

	      'seuil_eqm'=>3.0,

	      'seuil_sens'=>8.0,

	      'saisie_dpi'=>150,

	      'vector_scan_density'=>250,

	      'force_convert'=>'',

	      'n_procs'=>0,

	      'delimiteur_decimal'=>',',

	      'defaut_encodage_liste'=>'UTF-8',

	      'encodage_interne'=>'UTF-8',

	      'defaut_encodage_csv'=>'UTF-8',

	      'encodage_latex'=>'',

	      'defaut_moteur_latex_b'=>'pdflatex',

	      'defaut_seuil'=>0.15,

	      'defaut_seuil_up'=>1.0,

	      'assoc_window_size'=>'',

	      'mailing_window_size'=>'',

	      'preferences_window_size'=>'',

	      'checklayout_window_size'=>'',

	      'manual_window_size'=>'',

	      'conserve_taille'=>1,

	      'methode_impression'=>'CUPS',

	      'imprimante'=>'',

	      'printer_useful_options'=>'Staple Stapling StapleLocation StapleSet StapleOption',

	      'options_impression'=>{'sides'=>'two-sided-long-edge',

				     'number-up'=>1,

				     'repertoire'=>'/tmp',

				     'print_answersheet'=>'',

				     },

	      'manuel_image_type'=>'xpm',

	      'assoc_ncols'=>4,

	      'tolerance_marque_inf'=>0.2,

	      'tolerance_marque_sup'=>0.2,

	      'box_size_proportion'=>0.8,

	      'bw_threshold'=>0.6,

	      'ignore_red'=>0,

	      'try_three'=>1,

	      'prepare_solution'=>1,

	      'prepare_indiv_solution'=>1,

	      'prepare_catalog'=>1,

	      'symboles_trait'=>2,

	      'symboles_indicatives'=>'',

	      'symbole_0_0_type'=>'none',

	      'symbole_0_0_color'=>hex_color('black'),

	      'symbole_0_1_type'=>'circle',

	      'symbole_0_1_color'=>hex_color('red'),

	      'symbole_1_0_type'=>'mark',

	      'symbole_1_0_color'=>hex_color('red'),

	      'symbole_1_1_type'=>'mark',

	      'symbole_1_1_color'=>hex_color('blue'),

	      'annote_font_name'=>'Linux Libertine O 12',

	      'annote_ecart'=>5.5,

	      'annote_chsign'=>4,

	      'ascii_filenames'=>'',

	      'defaut_annote_rtl'=>'',

# TRANSLATORS: This is the default text to be written on the top of the first page of each paper when annotating. From this string, %s will be replaced with the student final mark, %m with the maximum mark he can obtain, %S with the student total score, and %M with the maximum score the student can obtain.

	      'defaut_verdict'=>"%(ID)\n".__("Mark: %s/%m (total score: %S/%M)"),

	      'defaut_verdict_q'=>"\"%"."s/%"."m\"",

	      'defaut_verdict_qc'=>"\"X\"",

	      'embedded_max_size'=>'1000x1500',

	      'embedded_format'=>'jpeg',

	      'embedded_jpeg_quality'=>75,

	      'zoom_window_height'=>400,

	      'zoom_window_factor'=>1.0,

	      'zooms_ncols'=>4,

	      'zooms_edit_mode'=>0,

	      'email_sender'=>'',

	      'email_cc'=>'',

	      'email_bcc'=>'',

	      'email_transport'=>'sendmail',

	      'email_sendmail_path'=>['commande',

				      '/usr/sbin/sendmail','/usr/bin/sendmail',

				      '/sbin/sendmail','/bin/sendmail'],

	      'email_smtp_host'=>'smtp',

	      'email_smtp_port'=>25,

# TRANSLATORS: Subject of the emails which can be sent to the students to give them their annotated completed answer sheet.

	      'defaut_email_subject'=>__"Exam result",

# TRANSLATORS: Body text of the emails which can be sent to the students to give them their annotated completed answer sheet.

	      'defaut_email_text'=>__"Please find enclosed your annotated completed answer sheet.\nRegards.",

	      'csv_surname_headers'=>'',

	      'csv_name_headers'=>'',

	      'notify_documents'=>0,

	      'notify_capture'=>1,

	      'notify_grading'=>1,

	      'notify_annotation'=>1,

	      'notify_desktop'=>1,

	      'notify_command'=>'',

	      );

# MacOSX universal command to open files or directories : /usr/bin/open

if(lc($^O) eq 'darwin') {

    for my $k (qw/pdf_viewer img_viewer csv_viewer ods_viewer xml_viewer tex_editor txt_editor dir_opener/) {

	$o_defaut{$k}=['commande','/usr/bin/open','open'];

    }

    $o_defaut{'html_browser'}=['commande','/usr/bin/open %u','open %u'];

}

# Default options for projects

my %projet_defaut=('texsrc'=>'',

		   'data'=>'data',

		   'cr'=>'cr',

		   'listeetudiants'=>'',

		   'notes'=>'notes.xml',

		   'seuil'=>'',

		   'seuil_up'=>'',

		   'encodage_csv'=>'',

		   'encodage_liste'=>'',

		   'maj_bareme'=>1,

		   'doc_question'=>'DOC-sujet.pdf',

		   'doc_solution'=>'DOC-corrige.pdf',

		   'doc_indiv_solution'=>'DOC-indiv-solution.pdf',

		   'doc_setting'=>'DOC-calage.xy',

		   'doc_catalog'=>'DOC-catalog.pdf',

		   'filter'=>'',

		   'filtered_source'=>'DOC-filtered.tex',

		   'modele_regroupement'=>'',

		   'regroupement_compose'=>0,

		   'regroupement_type'=>'STUDENTS',

		   'regroupement_copies'=>'ALL',

		   'note_null'=>0,

		   'note_min'=>'',

		   'note_max'=>20,

		   'note_max_plafond'=>1,

		   'note_grain'=>"0.5",

		   'note_arrondi'=>'inf',

		   'liste_key'=>'',

		   'assoc_code'=>'',

		   'moteur_latex_b'=>'',

		   'nom_examen'=>'',

		   'code_examen'=>'',

		   'nombre_copies'=>0,

		   'postcorrect_student'=>0,

		   'postcorrect_copy'=>0,

		   'postcorrect_set_multiple'=>'',

		   '_modifie'=>1,

		   '_modifie_ok'=>0,

		   'format_export'=>'CSV',

		   'after_export'=>'file',

		   'export_include_abs'=>'',

		   'annote_position'=>'marges',

		   'verdict'=>'',

		   'verdict_q'=>'',

		   'verdict_qc'=>'',

		   'annote_rtl'=>'',

		   'export_sort'=>'n',

		   'auto_capture_mode'=>-1,

		   'allocate_ids'=>0,

		   'email_col'=>'',

		   'email_subject'=>"",

		   'email_text'=>"",

		   'email_attachment'=>[],

		   'email_use_html'=>'',

		   );

# Add default project options for each export module:

my @export_modules=perl_module_search('AMC::Export::register');

for my $m (@export_modules) {

  load("AMC::Export::register::$m");

  my %d="AMC::Export::register::$m"->options_default;

  for(keys %d) {

    $projet_defaut{$_}=$d{$_};

  }

}

@export_modules=sort { "AMC::Export::register::$a"->weight

			 <=> "AMC::Export::register::$b"->weight }

  @export_modules;

# Reads filter plugins list

my @filter_modules=perl_module_search('AMC::Filter::register');

for my $m (@filter_modules) {

  load("AMC::Filter::register::$m");

}

@filter_modules=sort { "AMC::Filter::register::$a"->weight

			 <=> "AMC::Filter::register::$b"->weight }

  @filter_modules;

sub best_filter_for_file {

  my ($file)=@_;

  my $mmax='';

  my $max=-10;

  for my $m (@filter_modules) {

    my $c="AMC::Filter::register::$m"->claim($file);

    if($c>$max) {

      $max=$c;

      $mmax=$m;

    }

  }

  return($mmax);

}

# -----------------

my %o=();

my %state=();

## Notifications

sub notify_end_of_work {

  my ($action,$message)=@_;

  if($o{'notify_'.$action}) {

    if($o{'notify_desktop'}) {

      if($libnotify_error) {

	debug "Notification ignored: $libnotify_error";

      } else {

	my $notification=Notify::Notification->new('Auto Multiple Choice',$message,

						   '/opt/local/share/auto-multiple-choice/icons/auto-multiple-choice.svg');

	$notification->show;

      }

    }

    if($o{'notify_command'}) {

      my @cmd=map { s/[%]m/$message/g;s/[%]a/$action/g;$_; }

	quotewords('\s+',0,$o{'notify_command'});

      if(commande_accessible($cmd[0])) {

	commande_parallele(@cmd);

      } else {

	debug "ERROR: command '$cmd[0]' not found when trying to notify";

      }

    }

  }

}

# Test whether the magick perl package is installed

sub test_magick {

  if(!magick_perl_module(1)) {

    my $dialog = Gtk2::MessageDialog

      ->new_with_markup($w{'main_window'},

			'destroy-with-parent',

			'error','ok',

			__"None of the perl modules <b>Graphics::Magick</b> and <b>Image::Magick</b> are installed: AMC won't work properly!"

		       );

    $dialog->run;

    $dialog->destroy;

  }

}

# Test whether all commands defined to open/view files are

# reachable. If not, the user is warned...

sub test_commandes {

    my ($dont_warn)=@_;

    my @pasbon=();

    my @missing=();

    for my $c (grep { /_(viewer|editor|opener)$/ } keys(%o)) {

	my $nc=$o{$c};

	$nc =~ s/\s.*//;

	if(!commande_accessible($nc)) {

	    debug "Missing command [$c]: $nc";

	    push @missing,$c;

	    push @pasbon,$nc;

	}

    }

    if(@pasbon && !$dont_warn) {

	my $dialog = Gtk2::MessageDialog

	    ->new_with_markup($w{'main_window'},

			      'destroy-with-parent',

			      'warning','ok',

# TRANSLATORS: Message (first part) when some of the commands that are given in the preferences cannot be found.

			      __("Some commands allowing to open documents can't be found:")

			      ." ".join(", ",map { "<b>$_</b>"; } @pasbon).". "

# TRANSLATORS: Message (second part) when some of the commands that are given in the preferences cannot be found.

			      .__("Please check its correct spelling and install missing software.")." "

# TRANSLATORS: Message (third part) when some of the commands that are given in the preferences cannot be found. The %s will be replaced with the name of the menu entry "Preferences" and the name of the menu "Edit".

			      .sprintf(__"You can change used commands following <i>%s</i> from menu <i>%s</i>.",

# TRANSLATORS: "Preferences" menu

				       __"Preferences",

# TRANSLATORS: "Edit" menu

				       __"Edit"));

	$dialog->run;

	$dialog->destroy;

    }

    return(@missing);

}

# tests if debian package auto-multiple-choice-common is installed but

# not auto-multiple-choice...

sub deb_is_installed {

  my ($package_name)=@_;

  my $v='';

  open(QUERY,"-|","dpkg-query","-W",'--showformat=${Version}\n',$package_name);

  while(<QUERY>) {

    $v=$1 if(/^\s*([^\s]+)\s*$/);

  }

  close(QUERY);

  return($v);

}

sub test_debian_amc {

  if(commande_accessible("dpkg-query")) {

    if(deb_is_installed("auto-multiple-choice-common") &&

       !deb_is_installed("auto-multiple-choice")) {

      debug "ERROR: auto-multiple-choice package not installed!";

      my $dialog = Gtk2::MessageDialog

	->new_with_markup($w{'main_window'},

			  'destroy-with-parent',

			  'error','ok',

			  __"The package <i>auto-multiple-choice-common</i> is installed, but not <i>auto-multiple-choice</i>.\n<b>AMC won't work properly until you install auto-multiple-choice package!</b>"

			  );

      $dialog->run;

      $dialog->destroy;

    }

  }

}

# Creates general options directory if not present

if(! -d $o_dir) {

    mkdir($o_dir) or die "Error creating $o_dir : $!";

    # gets older verions (<=0.254) main configuration file and move it

    # to the new location

    if(-f $home_dir.'/.AMC.xml') {

	debug "Moving old configuration file";

	move($home_dir.'/.AMC.xml',$o_dir."/cf.default.xml");

    }

}

for my $o_sub (qw/plugins/) {

  mkdir("$o_dir/$o_sub") if(! -d "$o_dir/$o_sub");

}

#

sub sub_modif {

  my ($opts)=@_;

  my ($m,$mo)=($opts->{'_modifie'},$opts->{'_modifie_ok'});

  for my $k (keys %$opts) {

    if(ref($opts->{$k}) eq 'HASH') {

      ($m_sub,$mo_sub)=sub_modif($opts->{$k});

      $m=join_nonempty(',',$m,$m_sub);

      $mo=1 if($mo_sub);

    }

  }

  return($m,$mo);

}

sub clear_sub_modif {

  my ($data)=@_;

  delete($data->{_modifie});

  delete($data->{_modifie_ok});

  for my $k (grep { ref($data->{$_}) eq 'HASH' } (keys %$data)) {

    clear_sub_modif($data->{$k});

  }

}

# Read/write options XML files

sub pref_xx_lit {

  my ($fichier)=@_;

  if((! -f $fichier) || -z $fichier) {

    return();

  } else {

    debug("Reading XML config file $fichier ...");

    my $data=XMLin($fichier,SuppressEmpty => '',

		   ForceArray=>['docs','email_attachment','printer']);

    clear_sub_modif($data);

    return(%$data);

  }

}

sub pref_xx_ecrit {

    my ($data,$key,$fichier,$data_orig)=@_;

    if(open my $fh,">:encoding(utf-8)",$fichier) {

	XMLout($data,

	       "XMLDecl"=>'<?xml version="1.0" encoding="UTF-8" standalone="yes"?>',

	       "RootName"=>$key,'NoAttr'=>1,

	       "OutputFile" => $fh,

	       );

	close $fh;

	clear_sub_modif($data_orig || $data);

	return(0);

    } else {

	return(1);

    }

}

# Read/write running state

sub sauve_state {

    if($state{'_modifie'} || $state{'_modifie_ok'}) {

	debug "Saving state...";

	if(pref_xx_ecrit(\%state,'AMCState',$state_file)) {

	    my $dialog = Gtk2::MessageDialog

		->new($w{'main_window'},

		      'destroy-with-parent',

		      'error','ok',

# TRANSLATORS: Error writing one of the configuration files (global or project). The first %s will be replaced with the path of that file, and the second with the error text.

		      __"Error writing state file %s: %s",

		      $state_file,$!);

	    $dialog->run;

	    $dialog->destroy;

	} else {

	    $state{'_modifie'}=0;

	    $state{'_modifie_ok'}=0;

	}

    }

}

# annulation apprentissage

sub annule_apprentissage {

    my $dialog = Gtk2::MessageDialog

	->new_with_markup($w{'main_window'},

			  'destroy-with-parent',

			  'question','yes-no',

# Explains that some dialogs are shown only to learn AMC, only once by default (first part).

			  __("Several dialogs try to help you be at ease handling AMC.")." ".

# Explains that some dialogs are shown only to learn AMC, only once by default (second part). %s will be replaced with the text "Show this message again next time" that is written along the checkbox allowing the user to keep these learning message next time.

			  sprintf(__"Unless you tick the \"%s\" box, they are shown only once.",

# Explains that some dialogs are shown only to learn AMC, only once by default. This is the message shown along the checkbox allowing the user to keep these learning message next time.

				  __"Show this message again next time")." ".

# Explains that some dialogs are shown only to learn AMC, only once by default (third part). If you answer YES here, all these dialogs will be shown again.

			  __"Do you want to forgot which dialogs you have already seen and ask to show all of them next time they should appear ?"

			  );

    my $reponse=$dialog->run;

    $dialog->destroy;

    if($reponse eq 'yes') {

	debug "Clearing learning states...";

	$state{'apprentissage'}={};

	$state{'_modifie'}=1;

	sauve_state();

    }

}

# Read the state file

if(-r $state_file) {

    %state=pref_xx_lit($state_file);

    $state{'apprentissage'}={} if(!$state{'apprentissage'});

}

$state{'_modifie'}=0;

$state{'_modifie_ok'}=0;

# gets the last used profile

if(!$state{'profile'}) {

    $state{'profile'}='default';

    $state{'_modifie'}=1;

}

# sets new profile if given as a command argument

if($profile && $profile ne $state{'profile'}) {

    $state{'profile'}=$profile;

    $state{'_modifie'}=1;

}

sauve_state();

debug "Profile : $state{'profile'}";

$o_file=$o_dir."/cf.".$state{'profile'}.".xml";

# Read general options ...

if(-r $o_file) {

    %o=pref_xx_lit($o_file);

}

sub set_option_to_default {

    my ($key,$subkey,$force)=@_;

    if($subkey) {

	if($force || ! exists($o{$key}->{$subkey})) {

	    $o{$key}->{$subkey}=$o_defaut{$key}->{$subkey};

	    debug "New sub-global parameter : $key/$subkey = $o{$key}->{$subkey}";

	}

    } else {

	if($force || ! exists($o{$key})) {

	    # set to default

	    if(ref($o_defaut{$key}) eq 'ARRAY') {

		my ($type,@valeurs)=@{$o_defaut{$key}};

		if($type eq 'commande') {

		  UC: for my $c (@valeurs) {

		      if(commande_accessible($c)) {

			  $o{$key}=$c;

			  last UC;

		      }

		  }

		    if(!$o{$key}) {

			debug "No available command for option $key: using the first one";

			$o{$key}=$valeurs[0];

		    }

		} else {

		    debug "ERR: unknown option type : $type";

		}

	    } elsif(ref($o_defaut{$key}) eq 'HASH') {

		$o{$key}={%{$o_defaut{$key}}};

	    } else {

		$o{$key}=$o_defaut{$key};

		$o{$key}=$encodage_systeme if($key =~ /^encodage_/ && !$o{$key});

	    }

	    debug "New global parameter : $key = $o{$key}" if($o{$key});

	} else {

	    # already defined option: go with sub-options if any

	    if(ref($o_defaut{$key}) eq 'HASH') {

		for my $kk (keys %{$o_defaut{$key}}) {

		    set_option_to_default($key,$kk,$force);

		}

	    }

	}

    }

}

# sets undefined options to default value

for my $k (keys %o_defaut) {

    set_option_to_default($k);

}

# for unexisting commands options, see if we can find an available one

# from the default list

for my $k (test_commandes(1)) {

    set_option_to_default($k,'','FORCE');

}

# Clears modified flag for the options

$o{'_modifie'}=0;

$o{'_modifie_ok'}=0;

# some options were renamed to defaut_* between 0.226 and 0.227

for(qw/encodage_liste encodage_csv/) {

    if($o{"$_"} && ! $o{"defaut_$_"}) {

	$o{"defaut_$_"}=$o{"$_"};

	$o{'_modifie'}=1;

    }

}

# Replace old (pre 0.280) rep_modeles value with new one

if($o{'rep_modeles'} eq '/usr/share/doc/auto-multiple-choice/exemples') {

    $o{'rep_modeles'}=$o_defaut{'rep_modeles'};

    $o{'_modifie'}=1;

}

# Internal encoding _must_ be UTF-8, for XML::Writer (used by

# AMC::Gui::Association for example) to work

if($o{'encodage_interne'} ne 'UTF-8') {

    $o{'encodage_interne'}='UTF-8';

    $o{'_modifie'}=1;

}

# Reset projects directory to standard one

$o{'rep_projets'}=$shortcuts->absolu($o{'projects_home'});

# Warn if Notify is not available

sub test_libnotify {

  my $initted=eval { Notify::is_initted() };

  if(!$initted) {

    eval {

      Glib::Object::Introspection->setup(basename => 'Notify', version => '0.7', package => 'Notify') if(!defined($initted));

      # Set application name for notifications

      Notify::init('Auto Multiple Choice');

    };

    $libnotify_error=$@;

    if($libnotify_error && $o{'notify_desktop'}) {

      debug "libnotify loading error: $libnotify_error";

      my $dialog = Gtk2::MessageDialog

	->new_with_markup($w{'main_window'},

			  'destroy-with-parent',

			  'warning','ok',

			  "Please install <b>libnotify</b> to make desktop notifications available."

			 );

      $dialog->run;

      $dialog->destroy;

      $o{'notify_desktop'}='';

      $o{'_modifie'}=1;

    }

  }

}

# goes to a specific directory if the project directory is given as a

# command-line option

if(-f $project_dir) {

  $project_dir =~ s/\/?options\.xml$//;

}

$project_dir =~ s/\/+$//;

if(-d $project_dir) {

  my ($v,$d,$f)=splitpath($project_dir);

  $o{'rep_projets'}=catpath($v,$d,'');

  $o{'rep_projets'} =~ s/\/+$//;

  @ARGV=$f;

}

# creates projets and models directories if needed (if not present,

# Edit/Parameters can be disrupted)

for my $k (qw/rep_projets rep_modeles/) {

  my $path=$o{$k};

  if(-e $path) {

    debug "WARNING: $path ($k) is not a directory!" if(!-d $path);

  } else {

    mkdir($path);

  }

}

sub set_projects_home {

  my ($p)=@_;

  $o{'rep_projets'}=$p;

  $shortcuts->set(projects_path=>$p);

}

set_projects_home($o{'rep_projets'});

#############################################################################

my %projet=();

sub bon_encodage {

    my ($type)=@_;

    return($projet{'options'}->{"encodage_$type"}

	   || $o{"defaut_encodage_$type"}

	   || $o{"encodage_$type"}

	   || $o_defaut{"defaut_encodage_$type"}

	   || $o_defaut{"encodage_$type"}

	   || "UTF-8");

}

sub csv_build_0 {

  my ($k,@default)=@_;

  push @default,grep { $_ } map { s/^\s+//;s/\s+$//;$_; }

    split(/,+/,$o{'csv_'.$k.'_headers'});

  return("(".join("|",@default).")");

}

sub csv_build_name {

  return(csv_build_0('surname','nom','surname').' '

	 .csv_build_0('name','prenom','name'));

}

sub id2file {

    my ($id,$prefix,$extension)=(@_);

    $id =~ s/\+//g;

    $id =~ s/\//-/g;

    return($shortcuts->absolu($projet{'options'}->{'cr'})."/$prefix-$id.$extension");

}

sub is_local {

    my ($f,$proj)=@_;

    my $prefix=$o{'rep_projets'}."/";

    $prefix .= $projet{'nom'}."/" if($proj);

    if(defined($f)) {

	return($f !~ /^[\/%]/

	       || $f =~ /^$prefix/

	       || $f =~ /[\%]PROJET\//);

    } else {

	return('');

    }

}

sub fich_options {

    my ($nom,$rp)=@_;

    $rp=$o{'rep_projets'} if(!$rp);

    return "$rp/$nom/options.xml";

}

sub moteur_latex {

    my $m=$projet{'options'}->{'moteur_latex_b'};

    $m=$o{'defaut_moteur_latex_b'} if(!$m);

    $m=$o_defaut{'defaut_moteur_latex_b'} if(!$m);

    return($m);

}

sub read_glade {

    my ($main_widget,@widgets)=@_;

    my $g=Gtk2::Builder->new();

    my $glade_file=$glade_base.$main_widget.".glade";

    debug "Reading glade file ".$glade_file;

    $g->set_translation_domain('auto-multiple-choice');

    $g->add_from_file($glade_file);

    for ($main_widget,@widgets) {

	$w{$_}=$g->get_object($_);

	if($w{$_}) {

	    $w{$_}->set_name($_) if(!/^(apropos)$/);

	} else {

	    debug "WARNING: Object $_ not found in $main_widget glade file.";

	}

    }

    $g->connect_signals(undef);

    return($g);

}

# As a workaround for Bug #93 these widgets are disabled when Preferences window is opened.

# Since Bug #93 only affects Ubuntu 12.04 LTS, this workaround can be safely removed when

# Ubuntu 12.04 LTS reaches its end of life date i.e. April 2017

my @widgets_disabled_when_preferences_opened=(qw/menu_project menu_edit menu_tools menu_help/);

my @widgets_only_when_opened=(qw/cleanup_menu menu_projet_enreg menu_projet_modele/);

my $gui=read_glade('main_window',

		   qw/onglets_projet onglet_preparation preparation_etats

    but_question but_solution but_indiv_solution but_catalog doc_line1

    prepare_docs prepare_layout prepare_src

    state_layout state_src state_docs state_unrecognized state_marking state_assoc

    button_unrecognized button_show_missing

    edition_latex

    onglet_notation onglet_saisie onglet_reports

    log_general commande avancement annulation button_mep_warnings

    liste_filename liste_path liste_edit liste_setfile liste_refresh

    doc_menu menu_debug

    diag_tree state_capture

    maj_bareme regroupement_corriges

    groupe_model

    pref_assoc_c_assoc_code pref_assoc_c_liste_key

    export_c_format_export

    export_c_export_sort export_cb_export_include_abs

    config_export_modules standard_export_options

    notation_c_regroupement_type notation_c_regroupement_compose

    pref_prep_s_nombre_copies pref_prep_c_filter

    /,@widgets_only_when_opened,@widgets_disabled_when_preferences_opened);

# Grid lines are not well-positioned in RTL environments, I don't know

# why... so I remove them.

if($w{'main_window'}->get_direction() eq 'rtl') {

    debug "RTL mode: removing vertical grids";

    for(qw/documents diag inconnu/) {

	my $w=$gui->get_object($_.'_tree');

	$w->set_grid_lines('horizontal') if($w);

    }

}

$w{'commande'}->hide();

sub debug_set {

    $debug=$w{'menu_debug'}->get_active;

    debug "DEBUG MODE : OFF" if(!$debug);

    set_debug_mode($debug);

    if($debug) {

	debug "DEBUG MODE : ON";

	my $dialog = Gtk2::MessageDialog

	    ->new($w{'main_window'},

		  'destroy-with-parent',

		  'info','ok',

# TRANSLATORS: Messahe when switching to debugging mode.

		  __("Debugging mode.")." "

# TRANSLATORS: Messahe when switching to debugging mode. %s will be replaced with the path of the log file.

		  .sprintf(__"Debugging informations will be written in file %s.",AMC::Basic::debug_file()));

	$dialog->run;

	$dialog->destroy;

    }

}

$w{'menu_debug'}->set_active($debug);

# add doc list menu

my $docs_menu=Gtk2::Menu->new();

my @doc_langs=();

my $hdocdir=amc_specdir('doc/auto-multiple-choice')."/html/";

if(opendir(DOD,$hdocdir)) {

    push @doc_langs,map { s/auto-multiple-choice\.//;$_; } grep { /auto-multiple-choice\...(_..)?/ } readdir(DOD);

    closedir(DOD);

} else {

    debug("DOCUMENTATION : Can't open directory $hdocdir: $!");

}

# TRANSLATORS: One of the documentation languages.

my %ltext_loc=('French'=>__"French",

# TRANSLATORS: One of the documentation languages.

	       'English'=>__"English",

# TRANSLATORS: One of the documentation languages.

	       'Japanese'=>__"Japanese",

	       );

for my $l (@doc_langs) {

    my $ltext;

    $ltext=code2language($l);

    $ltext=$l if(! $ltext);

    $ltext=$ltext_loc{$ltext} if($ltext_loc{$ltext});

    my $m=Gtk2::ImageMenuItem->new_with_label($ltext);

    my $it=Gtk2::IconTheme->new();

    my ($taille,undef)=Gtk2::IconSize->lookup('menu');

    $it->prepend_search_path($hdocdir."auto-multiple-choice.$l");

    my $ii=$it->lookup_icon("flag",$taille ,"force-svg");

    if($ii) {

	$m->set_image(Gtk2::Image->new_from_pixbuf($it->load_icon("flag",$taille ,"force-svg")));

    }

    $m->signal_connect("activate",\&activate_doc,$l);

    $docs_menu->append($m);

}

$docs_menu->show_all();

$w{'doc_menu'}->set_submenu($docs_menu);

# make state entries with same background color as around...

$col=$w{'prepare_src'}->style()->bg('prelight');

for my $s (qw/normal insensitive/) {

  for my $k (qw/src docs layout capture marking unrecognized assoc/) {

    $w{'state_'.$k}->modify_base($s,$col);

  }

}

###

sub dialogue_apprentissage {

    my ($key,$type,$buttons,$force,@oo)=@_;

    my $resp='';

    $type='info' if(!$type);

    $buttons='ok' if(!$buttons);

    if($force || !$state{'apprentissage'}->{$key}) {

      my $garde;

      my $dialog = Gtk2::MessageDialog

	->new_with_markup($w{'main_window'},

			  'destroy-with-parent',

			  $type,$buttons,

			  @oo);

      if(!$force) {

	$garde=Gtk2::CheckButton->new(__"Show this message again next time");

	$garde->set_active(0);

	$garde->can_focus(0);

	$dialog->get_content_area()->add($garde);

      }

      $dialog->show_all();

      $resp=$dialog->run;

      if(!($force || $garde->get_active())) {

	debug "Learning : $key";

	$state{'apprentissage'}->{$key}=1;

	$state{'_modifie'}=1;

	sauve_state();

      }

      $dialog->destroy;

    }

    return($resp);

}

### COPIES

my $copies_store = Gtk2::ListStore->new ('Glib::String');

### FILES FOR TEMPLATE

my $template_files_store = Gtk2::TreeStore->new ('Glib::String',

						 'Glib::String');

### Unrecognized scans

my $inconnu_store = Gtk2::ListStore->new ('Glib::String','Glib::String',

					  'Glib::String','Glib::String',

					  'Glib::String');

$inconnu_store->set_sort_column_id(INCONNU_TIME_N,GTK_SORT_ASCENDING);

### modele EMAILS

my $emails_store=Gtk2::ListStore->new ('Glib::String',

				       'Glib::String',

				       'Glib::String',

				       'Glib::String',

				      );

### modele EMAILS

my $attachments_store=Gtk2::ListStore->new ('Glib::String',

					    'Glib::String',

					    'Glib::String',

					   );

### modele DIAGNOSTIQUE SAISIE

my $diag_store;

sub new_diagstore {

  $diag_store

    = Gtk2::ListStore->new ('Glib::String',

			    'Glib::String',

			    'Glib::String',

			    'Glib::String',

			    'Glib::String',

			    'Glib::String',

			    'Glib::String',

			    'Glib::String',

			    'Glib::String',

			    'Glib::String');

  $diag_store->set_sort_func(DIAG_EQM,\&sort_num,DIAG_EQM);

  $diag_store->set_sort_func(DIAG_DELTA,\&sort_num,DIAG_DELTA);

  $diag_store->set_sort_func(DIAG_ID,\&sort_from_columns,

			     [{'type'=>'n','col'=>DIAG_ID_STUDENT},

			      {'type'=>'n','col'=>DIAG_ID_COPY},

			      {'type'=>'n','col'=>DIAG_ID_PAGE},

			     ]);

}

sub sort_diagstore {

  $diag_store->set_sort_column_id(DIAG_ID,GTK_SORT_ASCENDING);

}

sub show_diagstore {

  $w{'diag_tree'}->set_model($diag_store);

}

new_diagstore();

sort_diagstore();

show_diagstore();

$renderer=Gtk2::CellRendererText->new;

# TRANSLATORS: This is the title of the column containing student/copy identifier in the table showing the results of data captures.

$column = Gtk2::TreeViewColumn->new_with_attributes (__"identifier",

						     $renderer,

						     text=> DIAG_ID,

						     'background'=> DIAG_ID_BACK);

$column->set_sort_column_id(DIAG_ID);

$w{'diag_tree'}->append_column ($column);

$renderer=Gtk2::CellRendererText->new;

# TRANSLATORS: This is the title of the column containing data capture date/time in the table showing the results of data captures.

$column = Gtk2::TreeViewColumn->new_with_attributes (__"updated",

						     $renderer,

						     text=> DIAG_MAJ);

$w{'diag_tree'}->append_column ($column);

$renderer=Gtk2::CellRendererText->new;

# TRANSLATORS: This is the title of the column containing Mean Square Error Distance (some kind of mean distance between the location of the four corner marks on the scan and the location where they should be if the scan was not distorted at all) in the table showing the results of data captures.

$column = Gtk2::TreeViewColumn->new_with_attributes (__"MSE",

						     $renderer,

						     'text'=> DIAG_EQM,

						     'background'=> DIAG_EQM_BACK);

$column->set_sort_column_id(DIAG_EQM);

$w{'diag_tree'}->append_column ($column);

$renderer=Gtk2::CellRendererText->new;

# TRANSLATORS: This is the title of the column containing so-called "sensitivity" (an indicator telling the user if the darkness ratio of some boxes on the page are very near the threshold. A great value tells that some darkness ratios are very near the threshold, so that the capture is very sensitive to the threshold. A small value is a good thing) in the table showing the results of data captures.

$column = Gtk2::TreeViewColumn->new_with_attributes (__"sensitivity",

						     $renderer,

						     'text'=> DIAG_DELTA,

						     'background'=> DIAG_DELTA_BACK);

$column->set_sort_column_id(DIAG_DELTA);

$w{'diag_tree'}->append_column ($column);

$w{'diag_tree'}->get_selection->set_mode(GTK_SELECTION_MULTIPLE);

# rajouter a partir de Encode::Supported

# TRANSLATORS: for encodings

my $encodages=[{qw/inputenc latin1 iso ISO-8859-1/,'txt'=>'ISO-8859-1 ('.__("Western Europe").')'},

# TRANSLATORS: for encodings

	       {qw/inputenc latin2 iso ISO-8859-2/,'txt'=>'ISO-8859-2 ('.__("Central Europe").')'},

# TRANSLATORS: for encodings

	       {qw/inputenc latin3 iso ISO-8859-3/,'txt'=>'ISO-8859-3 ('.__("Southern Europe").')'},

# TRANSLATORS: for encodings

	       {qw/inputenc latin4 iso ISO-8859-4/,'txt'=>'ISO-8859-4 ('.__("Northern Europe").')'},

# TRANSLATORS: for encodings

	       {qw/inputenc latin5 iso ISO-8859-5/,'txt'=>'ISO-8859-5 ('.__("Cyrillic").')'},

# TRANSLATORS: for encodings

	       {qw/inputenc latin9 iso ISO-8859-9/,'txt'=>'ISO-8859-9 ('.__("Turkish").')'},

# TRANSLATORS: for encodings

	       {qw/inputenc latin10 iso ISO-8859-10/,'txt'=>'ISO-8859-10 ('.__("Northern").')'},

# TRANSLATORS: for encodings

	       {qw/inputenc utf8x iso UTF-8/,'txt'=>'UTF-8 ('.__("Unicode").')'},

	       {qw/inputenc cp1252 iso cp1252/,'txt'=>'Windows-1252',

		alias=>['Windows-1252','Windows']},

# TRANSLATORS: for encodings

	       {qw/inputenc applemac iso MacRoman/,'txt'=>'Macintosh '.__"Western Europe"},

# TRANSLATORS: for encodings

	       {qw/inputenc macce iso MacCentralEurRoman/,'txt'=>'Macintosh '.__"Central Europe"},

	       ];

sub get_enc {

    my ($txt)=@_;

    for my $e (@$encodages) {

	return($e) if($e->{'inputenc'} =~ /^$txt$/i ||

		      $e->{'iso'} =~ /^$txt$/i);

	if($e->{'alias'}) {

	    for my $a (@{$e->{'alias'}}) {

		return($e) if($a =~ /^$txt$/i);

	    }

	}

    }

    return('');

}

# TRANSLATORS: you can omit the [...] part, just here to explain context

my $cb_model_vide_key=cb_model(''=>__p"(none) [No primary key found in association list]");

# TRANSLATORS: you can omit the [...] part, just here to explain context

my $cb_model_vide_code=cb_model(''=>__p"(none) [No code found in LaTeX file]");

my @printing_methods=();

for my $m ({name=>"CUPS",description=>"CUPS"},

	   {name=>"CUPSlp",description=>"CUPS (via lp)"},

	  ) {

  my $mod="AMC::Print::".lc($m->{name});

  load($mod);

  my $error=$mod->check_available();

  if(! $error) {

    push @printing_methods,$m->{name},$m->{description};

    if(!$o{methode_impression}) {

      $o{methode_impression}=$m->{name};

      $o{_modifie_ok}=1;

      debug "Switching to printing method <$m->{name}>.";

    }

  } else {

    if($o{methode_impression} eq $m->{name}) {

      $o{methode_impression}='';

      debug "Printing method <$m->{name}> is not available: $error";

    }

  }

}

if(!$o{methode_impression}) {

  $o{methode_impression}='commande';

  $o{_modifie_ok}=1;

  debug "Switching to printing method <commande>.";

}

push @printing_methods,

# TRANSLATORS: One of the printing methods: use a command (This is not the command name itself). This is a menu entry.

  'commande',__("command"),

# TRANSLATORS: One of the printing methods: print to files. This is a menu entry.

  'file',__("to files")

  ;

$prefs->store_register(

# TRANSLATORS: One option for decimal point: use a comma. This is a menu entry

    'delimiteur_decimal'=>cb_model(',',__", (comma)",

# TRANSLATORS: One option for decimal point: use a point. This is a menu entry.

				   '.',__". (dot)"),

# TRANSLATORS: One of the rounding method for marks. This is a menu entry.

    'note_arrondi'=>cb_model('inf',__"floor",

# TRANSLATORS: One of the rounding method for marks. This is a menu entry.

			     'normal',__"rounding",

# TRANSLATORS: One of the rounding method for marks. This is a menu entry.

			     'sup',__"ceiling"),

    'methode_impression'=>cb_model(@printing_methods),

# TRANSLATORS: you can omit the [...] part, just here to explain context

    'sides'=>cb_model('one-sided',__p("one sided [No two-sided printing]"),

# TRANSLATORS: One of the two-side printing types. This is a menu entry.

		      'two-sided-long-edge',__"long edge",

# TRANSLATORS: One of the two-side printing types. This is a menu entry.

		      'two-sided-short-edge',__"short edge"),

    'encodage_latex'=>cb_model(map { $_->{'iso'}=>$_->{'txt'} }

			       (@$encodages)),

# TRANSLATORS: you can omit the [...] part, just here to explain context

    'manuel_image_type'=>cb_model('ppm'=>__p("(none) [No transitional image type (direct processing)]"),

				  'xpm'=>'XPM',

				  'gif'=>'GIF'),

    'liste_key'=>$cb_model_vide_key,

    'assoc_code'=>$cb_model_vide_code,

    'format_export'=>cb_model(map { $_=>"AMC::Export::register::$_"->name() } (@export_modules)),

    'filter'=>cb_model(map { $_=>"AMC::Filter::register::$_"->name() } (@filter_modules)),

# TRANSLATORS: One of the actions that can be done after exporting the marks. Here, do nothing more. This is a menu entry.

    'after_export'=>cb_model(""=>__"that's all",

# TRANSLATORS: One of the actions that can be done after exporting the marks. Here, open the exported file. This is a menu entry.

			     "file"=>__"open the file",

# TRANSLATORS: One of the actions that can be done after exporting the marks. Here, open the directory where the file is. This is a menu entry.

			     "dir"=>__"open the directory",

    ),

# TRANSLATORS: you can omit the [...] part, just here to explain context

    'annote_position'=>cb_model("none"=>__p("(none) [No annotation position (do not write anything)]"),

# TRANSLATORS: One of the possible location for questions scores on annotated completed answer sheet: in one margin. This is a menu entry.

				"marge"=>__"in one margin",

# TRANSLATORS: One of the possible location for questions scores on annotated completed answer sheet: in one of the two margins. This is a menu entry.

				"marges"=>__"in the margins",

# TRANSLATORS: One of the possible location for questions scores on annotated completed answer sheet: near the boxes. This is a menu entry.

				"case"=>__"near boxes",

# TRANSLATORS: One of the possible location for questions scores on annotated completed answer sheet: in the zones defined in the source file

				"zones"=>__"where defined in the source",

    ),

# TRANSLATORS: One of the possible sorting criteria for students in the exported spreadsheet with scores: the student name. This is a menu entry.

    'export_sort'=>cb_model("n"=>__"name",

# TRANSLATORS: One of the possible sorting criteria for students in the exported spreadsheet with scores: the student sheet number. This is a menu entry.

			    "i"=>__"exam copy number",

# TRANSLATORS: One of the possible sorting criteria for students in the exported spreadsheet with scores: the line where one can find this student in the students list file. This is a menu entry.

			    "l"=>__"line in students list",

# TRANSLATORS: you can omit the [...] part, just here to explain context

# One of the possible sorting criteria for students in the exported spreadsheet with scores: the student mark. This is a menu entry.

			    "m"=>__p("mark [student mark, for sorting]"),

			    ),

    'embedded_format'=>cb_model('png'=>'PNG',

				'jpeg'=>'JPEG'),

# TRANSLATORS: One of the possible way to group annotated answer sheets together to PDF files: make one PDF file per student, with all his pages. This is a menu entry.

    'regroupement_type'=>cb_model('STUDENTS'=>__"One file per student",

# TRANSLATORS: One of the possible way to group annotated answer sheets together to PDF files: make only one PDF with all students sheets. This is a menu entry.

				  'ALL'=>__"One file for all students",

    ),

# TRANSLATORS: One of the possible way to annotate answer sheets: here we only select pages where the student has written something (in separate answer sheet mode, these are the pages from the answer sheet and not the pages from the subject).

    'regroupement_compose'=>cb_model(0=>__"Only pages with answers",

# TRANSLATORS: One of the possible way to annotate answer sheets: here we take the pages were the students has nothing to write (often question pages from a subject with separate answer sheet option) from the subject.

				     1=>__"Question pages from subject",

# TRANSLATORS: One of the possible way to annotate answer sheets: here we take the pages were the students has nothing to write (often question pages from a subject with separate answer sheet option) from the correction.

				     2=>__"Question pages from correction",

    ),

# TRANLATORS: For which students do you want to annotate papers? This is a menu entry.

    'regroupement_copies'=>cb_model('ALL'=>__"All students",

# TRANLATORS: For which students do you want to annotate papers? This is a menu entry.

				    'SELECTED'=>__"Selected students",

				    ),

    'auto_capture_mode'=>cb_model(-1=>__"Please select...",

# TRANSLATORS: One of the ways exam was made: each student has a different answer sheet with a different copy number - no photocopy was made. This is a menu entry.

				  0=>__"Different answer sheets",

# TRANSLATORS: One of the ways exam was made: some students have the same exam subject, as some photocopies were made before distributing the subjects. This is a menu entry.

				  1=>__"Some answer sheets were photocopied"),

# TRANSLATORS: One of the ways to send mail: use sendmail command. This is a menu entry.

    'email_transport'=>cb_model('sendmail'=>__"sendmail",

# TRANSLATORS: One of the ways to send mail: use a SMTP server. This is a menu entry.

				'SMTP'=>__"SMTP"),

    'print_extract_with'=>cb_model('pdftk'=>'pdftk',

				   'gs'=>'gs (ghostscript)'

				   ),

		       'print_answersheet'=>cb_model(''=>__"Standard",

# TRANLATORS: One of the way to handle separate answer sheet when printing: standard (same as in the question pdf document). This is a menu entry.

						     'split'=>__"Separate answer sheet",

# TRANLATORS: One of the way to handle separate answer sheet when printing: print separately answer sheet and question. This is a menu entry.

						     'first'=>__"Answer sheet first"),

# TRANLATORS: One of the way to handle separate answer sheet when printing: print the answr sheet first. This is a menu entry.

		      );

# TRANSLATORS: One of the signs that can be drawn on annotated answer sheets to tell if boxes are to be ticked or not, and if they were detected as ticked or not.

my $symbole_type_cb=cb_model("none"=>__"nothing",

# TRANSLATORS: One of the signs that can be drawn on annotated answer sheets to tell if boxes are to be ticked or not, and if they were detected as ticked or not.

			     "circle"=>__"circle",

# TRANSLATORS: One of the signs that can be drawn on annotated answer sheets to tell if boxes are to be ticked or not, and if they were detected as ticked or not. Here, a cross.

			     "mark"=>__"mark",

# TRANSLATORS: One of the signs that can be drawn on annotated answer sheets to tell if boxes are to be ticked or not, and if they were detected as ticked or not. Here, the box outline.

			     "box"=>__"box",

			     );

for my $k (qw/0_0 0_1 1_0 1_1/) {

  $prefs->store_register("symbole_".$k."_type"=>$symbole_type_cb);

}

# Add config GUI for export modules...

for my $m (@export_modules) {

  my $x="AMC::Export::register::$m"->build_config_gui(\%w,$prefs);

  if($x) {

    $w{'config_export_module_'.$m}=$x;

    $w{'config_export_modules'}->pack_start($x,0,0,0);

  }

}

### export

sub maj_export {

    my $old_format=$projet{'options'}->{'format_export'};

    valide_options_for_domain('export','',@_);

    if($projet{'options'}->{'_modifie'} =~ /\bexport_sort\b/) {

      annotate_source_change($projet{'_capture'},1);

    }

    debug "Format : ".$projet{'options'}->{'format_export'};

    for(@export_modules) {

      if($w{'config_export_module_'.$_}) {

	if($projet{'options'}->{'format_export'} eq $_) {

	  $w{'config_export_module_'.$_}->show;

	} else {

	  $w{'config_export_module_'.$_}->hide;

	}

      }

    }

    my %hide=("AMC::Export::register::".$projet{'options'}->{'format_export'})

      ->hide();

    for (qw/standard_export_options/) {

      if($hide{$_}) {

	$w{$_}->hide();

      } else {

	$w{$_}->show();

      }

    }

}

sub exporte {

  maj_export();

    my $format=$projet{'options'}->{'format_export'};

    my @options=();

    my $ext="AMC::Export::register::$format"->extension();

    if(!$ext) {

	$ext=lc($format);

    }

    my $type="AMC::Export::register::$format"->type();

    my $code=$projet{'options'}->{'code_examen'};

    $code=$projet{'nom'} if(!$code);

    my $output=$shortcuts->absolu('%PROJET/exports/'.$code.$ext);

    my @needs_module=();

    my %ofc="AMC::Export::register::$format"

      ->options_from_config($projet{'options'},\%o,\%o_defaut);

    for(keys %ofc) {

      push @options,"--option-out",$_.'='.$ofc{$_};

    }

    push @needs_module,"AMC::Export::register::$format"->needs_module();

    if(@needs_module) {

	# teste si les modules necessaires sont disponibles

	my @manque=();

	for my $m (@needs_module) {

	    if(!check_install(module=>$m)) {

		push @manque,$m;

	    }

	}

	if(@manque) {

	    debug 'Exporting to '.$format.': Needs perl modules '.join(', ',@manque);

	    my $dialog = Gtk2::MessageDialog

	      ->new($w{'main_window'},

		    'destroy-with-parent',

		    'error','ok',

		    __("Exporting to '%s' needs some perl modules that are not installed: %s. Please install these modules or switch to another export format."),

		    "AMC::Export::register::$format"->name(),join(', ',@manque)

		   );

	    $dialog->run;

	    $dialog->destroy;

	    return();

	}

    }

    commande('commande'=>["auto-multiple-choice","export",

			  pack_args(

				    "--debug",debug_file(),

				    "--module",$format,

				    "--data",$shortcuts->absolu($projet{'options'}->{'data'}),

				    "--useall",$projet{'options'}->{'export_include_abs'},

				    "--sort",$projet{'options'}->{'export_sort'},

				    "--fich-noms",$shortcuts->absolu($projet{'options'}->{'listeetudiants'}),

				    "--noms-encodage",bon_encodage('liste'),

				    "--csv-build-name",csv_build_name(),

				    ($projet{'options'}->{'annote_rtl'} ? "--rtl" : "--no-rtl"),

				    "--output",$output,

				    @options

				   ),

			 ],

	     'texte'=>__"Exporting marks...",

	     'progres.id'=>'export',

	     'progres.pulse'=>0.01,

	     'fin'=>sub {

	       my ($c,%data)=@_;

	       if(-f $output) {

		 # shows export messages

		 my $t=$c->higher_message_type();

		 if($t) {

		   my $dialog = Gtk2::MessageDialog

		     ->new($w{'main_window'},

			   'destroy-with-parent',

			   ($t eq 'ERR' ? 'error' : $t eq 'WARN' ? 'warning' : 'info'),

			   'ok',

			   join("\n",$c->get_messages($t))

			   );

		   $dialog->run;

		   $dialog->destroy;

		 }

		 if($projet{'options'}->{'after_export'} eq 'file') {

		   commande_parallele($o{$type.'_viewer'},$output)

		     if($o{$type.'_viewer'});

		 } elsif($projet{'options'}->{'after_export'} eq 'dir') {

		   view_dir($shortcuts->absolu('%PROJET/exports/'));

		 }

	       } else {

		 my $dialog = Gtk2::MessageDialog

		   ->new($w{'main_window'},

			 'destroy-with-parent',

			 'warning','ok',

			 __"Export to %s did not work: file not created...",$output);

		 $dialog->run;

		 $dialog->destroy;

	       }

	     }

	     );

}

## menu contextuel sur liste diagnostique -> visualisation zoom/page

# TRANSLATORS: One of the popup menu that appears when right-clicking on a page in the data capture diagnosis table. Choosing this entry, an image will be opened to see where the corner marks were detected.

my %diag_menu=(page=>{text=>__"page adjustment",icon=>'gtk-zoom-fit'},

# TRANSLATORS: One of the popup menu that appears when right-clicking on a page in the data capture diagnosis table. Choosing this entry, a window will be opened were the user can see all boxes on the scans and how they were filled by the students, and correct detection of ticked-or-not if needed.

	       zoom=>{text=>__"boxes zooms",icon=>'gtk-zoom-in'},

	       );

sub zooms_display {

    my ($student,$page,$copy,$forget_it)=@_;

    debug "Zooms view for ".pageids_string($student,$page,$copy)."...";

    my $zd=$shortcuts->absolu('%PROJET/cr/zooms');

    debug "Zooms directory $zd";

    if($w{'zooms_window'} &&

       $w{'zooms_window'}->actif) {

	$w{'zooms_window'}->page([$student,$page,$copy],$zd,$forget_it);

    } elsif(!$forget_it) {

	$w{'zooms_window'}=AMC::Gui::Zooms::new('seuil'=>$projet{'options'}->{'seuil'},

						'seuil_up'=>$projet{'options'}->{'seuil_up'},

						'n_cols'=>$o{'zooms_ncols'},

						'zooms_dir'=>$zd,

						'page_id'=>[$student,$page,$copy],

						'size-prefs',\%o,

						'encodage_interne'=>$o{'encodage_interne'},

						'data'=>$projet{'_capture'},

						'cr-dir'=>$shortcuts->absolu($projet{'options'}->{'cr'}),

						'list_view'=>$w{'diag_tree'},

						'global_options'=>\%o,

						'prefs'=>$prefs,

	    );

    }