#! /usr/bin/perl -w

#

# Copyright (C) 2008-2012 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 XML::Simple;

use IO::File;

use IO::Select;

use POSIX qw/strftime/;

use Time::Local;

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 Module::Load;

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

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::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,

};

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();

my $debug=0;

my $debug_file='';

my $profile='';

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

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

	   "profile=s"=>\$profile,

	   );

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 $glade_base=__FILE__;

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

my $home_dir=Glib::get_home_dir();

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());

}

my %w=();

# 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',

				    ],

# 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,

	      '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,

	      'taille_max_correction'=>'1000x1500',

	      'assoc_window_size'=>'',

	      'mailing_window_size'=>'',

	      'preferences_window_size'=>'',

	      'checklayout_window_size'=>'',

	      'manual_window_size'=>'',

	      'qualite_correction'=>'150',

	      'conserve_taille'=>1,

	      'methode_impression'=>'CUPS',

	      'imprimante'=>'',

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

				     'number-up'=>1,

				     'repertoire'=>'/tmp',

				     'split'=>'',

				     },

	      'manuel_image_type'=>'xpm',

	      'assoc_ncols'=>4,

	      'zooms_ncols'=>4,

	      'tolerance_marque_inf'=>0.2,

	      'tolerance_marque_sup'=>0.2,

	      'box_size_proportion'=>0.8,

	      'bw_threshold'=>0.6,

	      'ignore_red'=>0,

	      '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_ps_nl'=>60,

	      '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\"",

	      'zoom_window_height'=>400,

	      'zoom_window_factor'=>1.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'=>'',

	      );

# 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'=>'',

		   'encodage_csv'=>'',

		   'encodage_liste'=>'',

		   'maj_bareme'=>1,

		   'docs'=>['DOC-sujet.pdf','DOC-corrige.pdf','DOC-calage.xy'],

		   'filter'=>'',

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

		   'modele_regroupement'=>'',

		   'regroupement_compose'=>'',

		   'regroupement_type'=>'STUDENTS',

		   'regroupement_copies'=>'ALL',

		   '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,

		   '_modifie'=>1,

		   '_modifie_ok'=>0,

		   'format_export'=>'CSV',

		   'after_export'=>'file',

		   'export_include_abs'=>'',

		   'annote_position'=>'marges',

		   'verdict'=>'',

		   'verdict_q'=>'',

		   'annote_rtl'=>'',

		   'export_sort'=>'n',

		   'auto_capture_mode'=>-1,

		   'allocate_ids'=>0,

		   'email_col'=>'',

		   'email_subject'=>"",

		   'email_text'=>"",

		   'email_attachment'=>[],

		   );

# 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=();

# 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);

}

# 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.=','.$opts->{$k}->{'_modifie'} if($opts->{$k}->{'_modifie'});

      $mo=1 if($opts->{$k}->{'_modifie_ok'});

    }

  }

  return($m,$mo);

}

# Read/write options XML files

sub pref_xx_lit {

    my ($fichier)=@_;

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

	return();

    } else {

	return(%{XMLin($fichier,SuppressEmpty => '',ForceArray=>['docs','email_attachment'])});

    }

}

sub pref_xx_ecrit {

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

    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;

	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'}=absolu($o{'projects_home'});

# 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);

  }

}

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

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 raccourcis {

    my ($proj)=@_;

    my %pathes;

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

    $proj='' if(!defined($proj));

    if($proj eq '<HOME>') {

      %pathes=('%HOME',$home_dir);

    } else {

      %pathes=('%PROJETS'=>$o{'rep_projets'},

	       '%HOME',$home_dir,

	       ''=>'%PROJETS',

	      );

      if($proj) {

	$pathes{'%PROJET'}=$o{'rep_projets'}."/".$proj;

	$pathes{''}='%PROJET';

      }

    }

    return(\%pathes);

}

sub absolu {

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

    return($f) if(!defined($f));

    return(proj2abs(raccourcis($proj),$f));

}

sub relatif {

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

    return($f) if(!defined($f));

    return(abs2proj(raccourcis($proj),$f));

}

sub id2file {

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

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

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

    return(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);

}

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

    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_cb_regroupement_compose

    pref_prep_s_nombre_copies pref_prep_c_filter

    /,@widgets_only_when_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 %cb_stores=(

# 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('CUPS','CUPS',

# 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"),

# 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 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"=>__"sheet 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]"),

			    ),

# 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",

    ),

# 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"),

    );

# 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/) {

    $cb_stores{"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,\%cb_stores);

  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/) {

      $projet{'_report'}->begin_transaction('SMch');

      $projet{'_report'}->variable('grouped_uptodate',-3);

      $projet{'_report'}->end_transaction('SMch');

    }

    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=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",absolu($projet{'options'}->{'data'}),

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

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

				    "--fich-noms",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=shift;

	       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(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=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'},

						'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'=>absolu($projet{'options'}->{'cr'}),

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

	    );

    }

}

sub zooms_line_base {

  my ($forget_it)=@_;

  my @selected=$w{'diag_tree'}->get_selection->get_selected_rows;

  if(@selected) {

    my $iter=$diag_store->get_iter($selected[0]);

    my $id=$diag_store->get($iter,DIAG_ID);

    zooms_display((map { $diag_store->get($iter,$_) } (DIAG_ID_STUDENT,

						       DIAG_ID_PAGE,

						       DIAG_ID_COPY)

		  ),$forget_it);

  }

}

sub zooms_line { zooms_line_base(1); }

sub zooms_line_open { zooms_line_base(0); }

sub layout_line {

  my @selected=$w{'diag_tree'}->get_selection->get_selected_rows;

  for my $s (@selected) {

    my $iter=$diag_store->get_iter($s);

    my @id=map { $diag_store->get($iter,$_); } 

      (DIAG_ID_STUDENT,DIAG_ID_PAGE,DIAG_ID_COPY);

    $projet{'_capture'}->begin_read_transaction('Layl');

    my $f=absolu($projet{'options'}->{'cr'}).'/'

      .$projet{'_capture'}->get_layout_image(@id);

    $projet{'_capture'}->end_transaction('Layl');

    commande_parallele($o{'img_viewer'},$f) if(-f $f);

  }

}

sub delete_line {

  my @selected=$w{'diag_tree'}->get_selection->get_selected_rows;

  my $f;

  if(@selected) {

    my $dialog = Gtk2::MessageDialog

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

			'destroy-with-parent',

			'question','yes-no',

			sprintf((__"You requested to delete all data capture results for %d page(s)"),1+$#selected)."\n"

			.'<b>'.(__"All data and image files related to these pages will be deleted.")."</b>\n"

			.(__"Do you really want to continue?")

		       );

    my $reponse=$dialog->run;

    $dialog->destroy;

    if($reponse eq 'yes') {

      my @iters=();

      $projet{'_capture'}->begin_transaction('rmAN');

      for my $s (@selected) {

	my $iter=$diag_store->get_iter($s);

	my @id=map { $diag_store->get($iter,$_); } 

	  (DIAG_ID_STUDENT,DIAG_ID_PAGE,DIAG_ID_COPY);

	debug "Removing data capture for ".pageids_string(@id);

	#

	# 1) get image files generated, and remove them

	#

	my $crdir=absolu($projet{'options'}->{'cr'});

	my @files=();

	#

	# scan file

	push @files,absolu($projet{'_capture'}->get_scan_page(@id));

	#

	# layout image, in cr directory

	push @files,$crdir.'/'

	  .$projet{'_capture'}->get_layout_image(@id);

	#

	# annotated scan

	push @files,$crdir.'/corrections/jpg/'

	  .$projet{'_capture'}->get_annotated_page(@id);

	#

	# zooms

	push @files,map { $crdir.'/zooms/'.$_ } grep { defined($_) }

	  ($projet{'_capture'}->get_zones_images(@id,ZONE_BOX));

	#

	for (@files) {

	  if (-f $_) {

	    debug "Removing $_";

	    unlink($_);

	  }

	}

	#

	# 2) remove data from database

	#

	$projet{'_capture'}->delete_page_data(@id);

	if($projet{'options'}->{'auto_capture_mode'} == 1) {

	  $projet{'_scoring'}->delete_scoring_data(@id[0,2]);

	  $projet{'_association'}->delete_association_data(@id[0,2]);

	}

	push @iters,$iter;

      }

      for(@iters) { $diag_store->remove($_); }

      update_analysis_summary();

      $projet{'_capture'}->end_transaction('rmAN');

      assoc_state();

    }

  }

}

$w{'diag_tree'}->signal_connect('button_release_event' =>

    sub {

	my ($self, $event) = @_;

	return 0 unless $event->button == 3;

	my ($path, $column, $cell_x, $cell_y) =

	    $w{'diag_tree'}->get_path_at_pos ($event->x, $event->y);

	if ($path) {

	    my $iter=$diag_store->get_iter($path);

	    my $id=[map { $diag_store->get($iter,$_) } (DIAG_ID_STUDENT,

							DIAG_ID_PAGE,

							DIAG_ID_COPY)];

	    my $menu = Gtk2::Menu->new;

	    my $c=0;

	    my @actions=('page');

	    # new zooms viewer

	    $projet{'_capture'}->begin_read_transaction('ZnIm');

	    my @bi=grep { -f absolu('%PROJET/cr/zooms')."/".$_ }

	      $projet{'_capture'}->zone_images($id->[0],$id->[2],ZONE_BOX);

	    $projet{'_capture'}->end_transaction('ZnIm');

	    if(@bi) {

		$c++;

		my $item = Gtk2::ImageMenuItem->new($diag_menu{'zoom'}->{text});

		$item->set_image(Gtk2::Image->new_from_icon_name($diag_menu{'zoom'}->{icon},'menu'));

		$menu->append ($item);

		$item->show;

		$item->signal_connect (activate => sub {

		    my (undef, $sortkey) = @_;

		    zooms_display(@$id);

				       }, $_);

	    } else {

		push  @actions,'zoom';

	    }

	    # page viewer and old zooms viewer

	    foreach $a (@actions) {

	      my $f;

	      if($a eq 'page') {

		$projet{'_capture'}->begin_read_transaction('gLIm');

		$f=absolu($projet{'options'}->{'cr'}).'/'

		  .$projet{'_capture'}->get_layout_image(@$id);

		$projet{'_capture'}->end_transaction('gLIm');

	      } else {

		$f=id2file($id,$a,'jpg');

	      }

	      if(-f $f) {

		$c++;

		my $item = Gtk2::ImageMenuItem->new($diag_menu{$a}->{text});

		$item->set_image(Gtk2::Image->new_from_icon_name($diag_menu{$a}->{icon},'menu'));

		$menu->append ($item);

		$item->show;

		$item->signal_connect (activate => sub {

					 my (undef, $sortkey) = @_;

					 debug "Looking at $f...";

					 commande_parallele($o{'img_viewer'},$f);

				       }, $_);

	      }

	    }

	    $menu->popup (undef, undef, undef, undef,

			  $event->button, $event->time) if($c>0);

	    return 1; # stop propagation!

	}

    });

### Appel a des commandes externes -- log, annulation

my %les_commandes=();

my $cmd_id=0;

sub commande {

    my (@opts)=@_;

    $cmd_id++;

    my $c=AMC::Gui::Commande::new('avancement'=>$w{'avancement'},

				  'log'=>$w{'log_general'},

				  'finw'=>sub {

				      my $c=shift;

				      $w{'onglets_projet'}->set_sensitive(1);

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

				      delete $les_commandes{$c->{'_cmdid'}};

				  },

				  @opts);

    $c->{'_cmdid'}=$cmd_id;

    $les_commandes{$cmd_id}=$c;

    $w{'onglets_projet'}->set_sensitive(0);

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

    $c->open();

}

sub commande_annule {

    for (keys %les_commandes) { $les_commandes{$_}->quitte(); }

}

sub commande_parallele {

    my (@c)=(@_);