################################################################################
#     TkCdrecord
#     Licence GPL (http://www.gnu.org/copyleft/gpl.html)
#     front-end for cdrtools
#     http://gnuprog.info/tkcdrecord.php
#     Auteur : Aubry Yves
################################################################################

#source tile07.kit
# Extension pour les thèmes:
package require tile

# starkit:
package provide app-tkcdrecord 1.0

package require BWidget


bind . <Control-q> exit
bind . <Alt-o> setup

wm title . "Tkcdrecord (GPL)"

menu .menu -tearoff 0 -fg blue
menu .menu.fichier -tearoff 0 -fg blue 
.menu add cascade -label "Fichier" -menu .menu.fichier -underline 0
.menu.fichier add command -label "Options" -accelerator "Alt+o" -command {setup} -underline 0 
.menu.fichier add command -label "Quit" -accelerator "Control-q" -command {exit}

menu .menu.eff -tearoff 0 -fg blue 
.menu add cascade -label "Effacer" -menu .menu.eff 
.menu.eff add command -label "CD-RW" -command EraseCD -underline 0 
.menu.eff add command -label "DVD RW" -command EraseCD -underline 0 

menu .menu.proj -tearoff 0 -fg blue
.menu add cascade -label "Projet" -menu .menu.proj
.menu.proj add command -label "CD/DVD de données" -command "SelectFiles 0" -underline 0
.menu.proj add command -label "CD audio" -command "SelectFiles 1" -underline 0
.menu.proj add command -label "Graver image" -command "fenGravure iso" -underline 0
.menu.proj add command -label "Copie de CD" -command CopieCd

menu .menu.aide -tearoff 0 -fg blue
.menu add cascade -label "?" -menu .menu.aide
.menu.aide add command -label "A propos" -command "apropos" -underline 0
#.menu.aide add command -label "Aide" -command "afficher-aide" -underline 0

set tile 1
# menu thème, necessite l'extension tile:
if {$tile} {

  .menu.aide add cascade -label "thèmes" -menu .menu.aide.theme
  menu .menu.aide.theme -tearoff 0 -fg blue
  set listeThemes "clam default classic alt winnative xpnative aqua plastik keramik" ;#blue  sriv srivlg  step
 foreach th $listeThemes {
   if  { ![catch {tile::setTheme $th}] } {
     # ajout d'un menu uniquement pour les thèmes disponibles
     .menu.aide.theme add radio  -label $th -state normal -variable theme -value $th -command "tile::setTheme $th"
   }
  }
}



. configure -menu .menu

ttk::frame .toolbar

ttk::button .toolbar.erase -text "Effacer un disque" -width 17 -command EraseCD
ttk::button .toolbar.creeiso -text "CD ou DVD de données" -width 20 -command "SelectFiles 0"
ttk::button .toolbar.burniso -text "Graver une image iso" -width 17 -command "fenGravure iso"
ttk::button .toolbar.burnaudio -text "Cd audio" -width 16 -command "SelectFiles 1"
ttk::button .toolbar.cp -text "Copie de Cd" -width 16 -command "CopieCd"
pack .toolbar.erase .toolbar.cp .toolbar.creeiso .toolbar.burniso .toolbar.burnaudio -side left ;#
pack .toolbar

ttk::frame .res -relief solid 
text  .res.result -width 50 -height 6 -yscrollcommand ".res.scroll set" ;#-bg white -fg blue
ttk::scrollbar .res.scroll -command ".res.result yview"

pack .res.result  -side left -expand 1 -fill both
pack .res.scroll -side right -fill y 
pack .res -pady 2 -fill both -expand 1

focus -force .

proc apropos {} {
  set msg " Tkcdrecord est sous licence GPL \n site:http://gnuprog.info/tkcdrecord.php"
  tk_messageBox -icon info -message $msg -title "A propos" -parent . -type ok
}

proc select_drive {perif line} {
  global param
  set id [open $param(confile) "w"]
  if {$perif=="grav"} {
  
    set param(grav) [lindex $line 0]
   
    
    .configcd.confirm configure -state active
  } else  {
  set param(lect) [lindex $line 0]
  }
}

proc enable_bt {state} {

  .toolbar.erase configure -state $state
  .toolbar.creeiso configure -state $state
  .toolbar.burniso configure -state $state
  .toolbar.burnaudio configure -state $state
  .toolbar.cp configure -state $state
}


proc setup {} {
  # fenetre de configuration
    global param lect
    detectdrive
    
    toplevel .configcd
    ttk::label .configcd.label1 -text "choisissez le graveur parmi les lecteurs suivant"
    listbox .configcd.lconf -height 2 -width 50 
    
    set param(dev) "scsi"
    ttk::label .configcd.lblect -text "Lecteur cd/dvd pour les copies:"
    listbox .configcd.lconf2 -height 2 -width 50 
    
    ttk::label .configcd.lb1 -text "Vitesse de gravure maximale"
    ttk::entry .configcd.speed -width 3 -state normal -textvariable param(speed) 
    ttk::button .configcd.confirm -text "OK" -command {destroy .configcd; savConf} 
    if {([info exists param(lect)]!=1) || ([info exists param(grav)]!=1)} {
      .configcd.confirm configure -state disabled
    }
    
    
    # le tableau lect contient la liste des lecteurs/graveurs détectés
    for  {set j 0} {$j<$lect(n)} {incr j} {
      .configcd.lconf insert end $lect($j)
      .configcd.lconf2 insert end $lect($j)
    }
    
 
    ComboBox .configcd.comb -width 35 -editable false  -values {Détecter\ les\ lecteurs\ au\ démarrage Sauvegarder\ la\ configuration\ des\ lecteurs}  -modifycmd  {set param(savconfl) [.configcd.comb getvalue]}
    pack .configcd.label1 .configcd.lconf .configcd.lblect .configcd.lconf2 -side top
    
    pack .configcd.comb
    .configcd.comb setvalue @$param(savconfl) ;#first
    
    pack .configcd.lb1 .configcd.speed -side left -padx 10
    
    pack .configcd.confirm -padx 2 -pady 2
   # litConf
    focus -force .configcd.lconf
    bind .configcd.lconf <ButtonRelease-1> { select_drive grav [selection get]   }
    bind .configcd.lconf2 <ButtonRelease-1> { select_drive lect [selection get]   }
    bind .configcd <Escape> "destroy .configcd"
}

proc detectdrive {} {
  global param lect
  eval "exec $param(cdrdao) scanbus >& $param(logfile)"
  
  # sous linux2.6: cdrecord -scanbus dev=ATAPI
  .res.result insert end "\ndétection des lecteurs:"
  set cdrinf [open $param(logfile)]
  set grav 0 ;# nb de graveurs trouvés
  set i 0
  
  while {[gets $cdrinf line] >=0} {
    
    if {([string first "CD" $line] > 3) || ([string first "DVD" $line] > 3)} {
      set lect($i) $line
      # if {$param(savconfl)==0} {}
        if {([string first "RW" $line]>0) && ($grav==0) } {
          set param(grav) [lindex $line 0]
          incr grav
          .res.result insert end "\n graveur:$line"
        } else  {
          set param(lect) [lindex $line 0]
          .res.result insert end "\n lecteur:$line"
        }
     #
      incr i
    }
  }
  set lect(n) $i
  #.res.result insert end "DEbug: i=$i [info exists param(grav)]"
  if { ($i==1) && ([info exists param(grav)]) } { ;# ($param(savconfl)==0) &&
    set param(lect) $param(grav)
   # .res.result insert end "1 seul graveur, pas de lecteur détecté\n"
  }
  if { ! [info exists param(grav)] } {
    set param(grav) 0
    tk_messageBox -icon warning -message "Aucun graveur détecté " -title "Attention" -parent . -type ok
  }
  close $cdrinf
  
}


proc init {} {
    global param
    global tcl_platform
    set param(os) $tcl_platform(platform)

    if {$param(os)=="windows"} {
     
      # set param(cdrecord) "$starkit::topdir/exe/cdrecord.exe"
      # set param(cdrdao) "$starkit::topdir/exe/cdrdao.exe"
      # set param(mkisofs) "$starkit::topdir/exe/mkisofs.exe"
      set param(cdrecord) "./cdrecord.exe"
      set param(cdrdao) "./cdrdao.exe"
      set param(mkisofs) "./mkisofs.exe"
    } else  {
        set param(cdrecord) "cdrecord"
        set param(cdrdao) "cdrdao"
        set param(mkisofs) "mkisofs"
     }
    set param(iso) ""
    set param(speed) 16 ;# valeur par défaud
    set param(blank) fast
    set param(multi) "false"
    set param(nom_iso) "TkCdrecord"
    set param(ferme) "true"
    set param(confile) cdr.dat ;# fichier de configuration
    set param(logfile) burn.log
    set param(savconfl) 0 ;# 0 détecter les lecteurs, 1 sauvegarder la config
    # Autres thèmes possibles: default , classic, alt,  winnative,	xpnative, clam
    catch {tile::setTheme plastik } {
      
    }
   
    if { [file exists $param(confile)] } {
      litConf
      #tk_messageBox -icon info -message "lecture config:$param(confile) savconfl:$param(savconfl)" -title "Debug" -parent . -type ok
    }
    
    if {$param(savconfl)==0} {
      detectdrive
      #tk_messageBox -icon info -message "Detection Graveur" -title "Debug" -parent . -type ok
    }
    if {([info exists param(lect)]!=1) || ([info exists param(grav)]!=1) } {
        setup
    }
       
    
}

proc litConf {} {
    global param
    # Le fichier de configuration est un simple fichier tcl initialisant des variables
     catch { source $param(confile) } fid 
   
}

proc savConf {} {
  global param
  set id [open $param(confile) "w"]
  puts $id "# Fichier de configuration de Tkcdrecord"
  
    
  puts $id "# Vitesse de gravure CD par défaut:\nset param(speed) \"$param(speed)\""
  puts $id "set param(savconfl) \"$param(savconfl)\""
  if {$param(savconfl)} {
   
    catch {puts $id "#Emplacement du graveur:\nset param(grav) \"$param(grav)\""
    }
    catch {puts $id "set param(lect) \"$param(lect)\""}
  }
  
  close $id
  
}

proc EraseCD {} {
    global param
    if {[catch {toplevel .eraseCd}]} {
      # evite les erreurs en cas d'appuis multiples sur le bouton erase
      focus -force .eraseCd
      return 
    }
    
    ttk::frame .eraseCd.chx
    radiobutton .eraseCd.chx.fast -text "Rapide" -variable param(blank) -value fast
    radiobutton .eraseCd.chx.all -text "Complet" -variable param(blank) -value all
    
    grid .eraseCd.chx.fast .eraseCd.chx.all -row 0
    pack .eraseCd.chx -fill both
    
    
    ttk::button .eraseCd.cancel -text "  Quit  "  -command {destroy .eraseCd}
    
    ttk::button .eraseCd.btreturn -text " Effacer "  -command {
        destroy .eraseCd
        
        enable_bt disable
        
       # set cmde "$param(cdrecord) -v -speed=$param(speed) -dev=$param(grav) -blank=$param(blank) " 
        set pipe [open "| $param(cdrecord) -v -speed=$param(speed) -dev=$param(grav) -blank=$param(blank) " r+]
        catch { fileevent $pipe readable [list litpipe $pipe .res.result erase] } fid
        
        # fileevent $f readable {
          # set l [gets $f]
          # 
          # if {[eof $f]} {
            # .res.result insert end "$l\n"
            # update idletasks
            # fileevent $f readable {}
            # 
            # catch { close $f }
            # tk_messageBox -icon info -message "Effacement terminé" -title "" -parent . -type ok
            # enable_bt active
            # 
          # } else {
            # .res.result insert end "\n $l"
            # update idletasks
            # #.res.result configure\
          # }
        # }
        
        
        
    }
    pack .eraseCd.btreturn .eraseCd.cancel  -pady 3 -padx 10 -side left

    
}

proc GraveData {} {
  # Gravure de donnee à la volée (pipe de mkisofs -> cdrecord)
  global param
    destroy .gravure
   
   # set cmde "exec $param(cmde) | ./cdrecord.exe -v -dev $param(grav) -speed=$param(speed) -driveropts=burnproof  -data -pad - "
    
    set pipe [open "| $param(cmde) | ./cdrecord.exe -v -dev $param(grav) -driveropts=burnproof  -speed=$param(speed) -data -pad - " ]
    .res.result delete 0.0 end
    .res.result insert 0.0 "Lancement de la gravure:\n "
   # catch {eval $cmde }
   #.res.result insert end "\n Gravure terminé"
    set param(cmde) ""
    
      catch { fileevent $pipe readable [list litpipe $pipe .res.result graveD] } fid
    
}

proc fenGravure {chx} {
  # chx= iso gravure d'iso , 0=sinon gravure à la volée
global param
    if { (![info exists param(grav)]) || ($param(grav)==0)} {
      tk_messageBox -icon error -message "Graveur introuvable" -title "Erreur" -parent . -type ok
      return
    }
    
    if {[catch {toplevel .gravure}]} {
      focus -force .gravure
      # evite les erreurs en cas d'appuis multiples sur le bouton qui appel cette fonction
      return
    }
    checkbutton .gravure.multi -text "CD multi-session" -variable param(multi)
    checkbutton .gravure.session -text "Fermer le cd    " -variable param(ferme)
    spinbox .gravure.vitesse -from 1 -to 48 -increment 2 -width 5 -vcmd {string is integer %P} -textvariable param(speed)
    ttk::label .gravure.lb1 -text "Vitesse de gravure:"
    if {$chx=="iso"} {
      ttk::button .gravure.launch -text "Graver" -command "GraveImg"
    } else  {
      # gravure à la volée
      ttk::button .gravure.launch -text "Graver" -command "GraveData"
    }
    
    
    grid .gravure.multi .gravure.session -padx 4
    grid .gravure.lb1
    grid .gravure.vitesse .gravure.launch -pady 4 ;# .gravure.session
    focus -force .gravure
}

proc GraveImg { } {
global param
    
     destroy .gravure 
     
      
  	    set types {
                  {{images}       {.iso}        }           
                  {{Tous}        *             }
          }
  
          set param(iso) [tk_getOpenFile -initialdir "./" -filetypes $types -parent .]
     
      if {[file exists $param(iso)]} {
          set option "-driveropts=burnproof "
          if { ($param(multi) ) && (! $param(ferme) ) } {
            set option "-multi"
           
          }
          .res.result insert end "\n$param(cdrecord) -v -speed=$param(speed) $option -dev=$param(grav) -data $param(iso)"
          .res.result insert end "\nLancement de la gravure, veuillez patienter"
          puts "$param(cdrecord) -v -speed=$param(speed) $option -dev=$param(grav) -data $param(iso) "
          set pipe [open "| $param(cdrecord) -v -speed=$param(speed) $option -dev=$param(grav) -data $param(iso) " ]
          # activer le burnproof: driveropts=burnproof
          
          catch { fileevent $pipe readable [list litpipe $pipe .res.result graveD] } fid
         
         
     }
  
}



proc du { data } {
  global param
  #tk_messageBox -icon info -message "pwd:[pwd] \n $param(datalist)" -title "debug" -parent . -type ok
  if {$data=="{}"} {
    return 0
  }
  if { $param(os)=="unix" } {
  set cmde "set t \[ exec $param(mkisofs) -Rq -print-size $data  \]"
  } else {
    set cmde "set t \[ exec $param(mkisofs) -Rq -print-size $data \]"
  }
  eval $cmde
  
  set param(taille) [expr $param(taille) + $t * 2.048]
  #tk_messageBox -icon info -message "taille:$param(taille)" -title "debug" -parent . -type ok
  
}


proc add_dir {fich parent} {
  global param tsel
  set ftail [file tail $fich]
  if { [file isdirectory $fich] } {
    
    $param(tree) insert end $parent $fich -text $ftail -image   [Bitmap::get folder]  -drawcross allways -data "dir"
    #incr param(filenode)
    # liste des fichiers du repertoire:
    set lentries [glob -nocomplain [file join $fich "*"]]
    foreach f $lentries {
      add_dir $f $fich
      
    }
  } else {
    # TREE inssert end parent node-name -text texte -data data
  $param(tree) insert end $parent $fich -text $ftail -data $fich
   # incr param(filenode)
  }
  
}


proc Add_data {mode} {
global param projet
  if {$mode=="dir"} {
      set newdata "\{[tk_chooseDirectory -initialdir "./" -parent .select]\}"
      # -multiple true
    } else  {
	if {$param(typeP)=="data"} {
		set types {
		{{Tous}        *             }
		}
	} else {
		set types {
		  {{Audio}     {.wav}  }
		
		}
	}
        set newdata [tk_getOpenFile -filetypes $types -parent .select -multiple true ]
    }
    if {($newdata != "") && ($newdata != "{}")} {
        if {$mode=="dir"} {
          #set newdir  [string range $newdata [expr [string last "/" $newdata]+1] [string length $newdata]]
          # tk_messageBox -icon info -message "newdata:$newdata \n newdir:$newdir" -title "debug" -parent . -type ok
                        
            set projet(dirlist) "$projet(dirlist)$newdata "
            du  $newdata ;# calcul de la taille de l'image
            regsub -all "{" $newdata "" t
            regsub -all "}" $t "" t
            add_dir $t root
            
           #$param(tree) insert end  root "$newdata" -text "$newdata" -data "$newdata" -image [Bitmap::get openfold]
        } else  {
                     
          update          
          
          
          set projet(filelist) "$projet(filelist)$newdata "
         
          
          du $newdata ;# calcul de la taille de l'image
          #.select.f1.aff insert end "$newdata\n"
          foreach t $newdata {
            #$param(tree) insert end  root "$t" -text "$t" -data "$t"
            $param(tree) insert end  root "$t" -text "$t" -data "$t"
           # incr param(filenode)
          }
          
          #$param(tree) insert end  root "$newdata" -text "$newdata" -data "$newdata" -open 1 ;#-image [Bitmap::get openfold]
          
        }
      
        
    }
   # set param(taillek) [expr $param(taille) / 1000]
    set param(tailleM) [expr $param(taille) / 1024.0]
    
}

# efface les fichiers du projet
proc delproj {} {
global param
  
  set projet(dirlist) ""
  set param(taille) 0
  set param(tailleM) 0
  set projet(filelist) ""
  set ch [$param(tree) nodes "root"]
  $param(tree) delete $ch
  
}


proc SelectFiles { mode } {
  # fenêtre de sélection des fichiers & dossiers à graver
  global param projet
  if {$mode==0} { set param(typeP) "data" } else { set param(typeP) "audio" }
  
  if {[catch {ttk::frame .select ; pack .select -side top -fill both}]} {
    destroy .select
    # focus -force .select
    # evite les erreurs en cas d'appuis multiples sur le bouton
    return
  }
    
  set projet(dlist) ""
  set projet(dirlist) ""
  set projet(filelist) ""  
  
  set param(taille) 0
  # set param(taillek) [expr $param(taille) / 1000]
  set param(tailleM) [expr $param(taille) / 1024.0]
  
  ttk::label .select.lb1 -text "Liste des fichiers à graver:"
  ttk::frame .select.f1
  ttk::frame .select.f2
  ttk::frame .select.ft ;#-bg white -relief ridge
  
  ttk::label .select.ft.lbt -text "nom du cd/dvd:"
  ttk::entry .select.ft.name -textvariable param(nom_iso) -width 15
  ttk::label .select.ft.lbt1 -text " Taille totale:"
  ttk::label .select.ft.taille -textvariable param(tailleM)  ;#-fg blue ;#-width 5
  ttk::label .select.ft.lbt2 -text "Mo" ;#-fg red
  pack .select.ft.lbt .select.ft.name .select.ft.lbt1 .select.ft.taille .select.ft.lbt2 -side left
  
  checkbutton .select.ft.multi -text "CD multi-session" -variable param(multi)
  # pack .select.lb1 -side top
    
  # Arbrorescence des fichiers à graver
  Tree .select.f1.aff -width 50 -xscrollcommand {.select.f1.scroll set}
  
  
  set param(tree) ".select.f1.aff"
  ttk::scrollbar .select.f1.scroll -command ".select.f1.aff yview"
  
  
  ttk::button .select.f2.addir -text "Ajouter un dossier" -command "Add_data dir"
  ttk::button .select.f2.addfile -text "Ajouter des fichiers" -command "Add_data file"
  ttk::button .select.f2.eff -text "effacer tout" -command { delproj } 
  ttk::button .select.f2.annul -text "Quitter" -command {delproj ; destroy .select}
  if { $param(typeP)=="data"} {
    ttk::button .select.f2.ok -text "Céer image" -command "makeIso 0"
    ttk::button .select.f2.gra -text "Graver" -command {makeIso 1}
    pack .select.f2.addir .select.f2.addfile .select.f2.eff .select.f2.ok .select.f2.gra .select.f2.annul -side top -fill x
  } else {
    # CD AUDIO
    .select.lb1 configure -text "Liste des fichiers audio"
    ttk::button .select.f2.ok -text "OK" -command "BurnAudio"
    pack .select.f2.addfile .select.f2.eff .select.f2.annul .select.f2.ok -side top -fill x
  }
  pack .select.f1.aff -side left -expand 1 -fill both
  # pack .select.f2 -side right
  pack .select.f1.scroll -side right -fill y
  #grid .select.f1.aff .select.f1.scroll
    
  grid .select.lb1 -row 1
  grid .select.f1 .select.f2 -row 2 -padx 2

  
  
  if {$param(typeP)=="data"} {
    pack .select.ft.multi -side right
    #grid .select.multi 
  }
  grid .select.ft -columnspan 3
}


proc getdatalist {} {
# prepare la liste de fichiers & repertoire pour mkisofs
  global param projet
  set projet(dlist) $projet(filelist)
  
  foreach dir $projet(dirlist) {
    set newdir  [string range $dir [expr [string last "/" $dir]+1] [string length $dir]]
    regsub -all " " $newdir "\\ " newdir
    regsub -all " " $dir "\\ " dir
    set projet(dlist) "$projet(dlist) $newdir/=$dir"
  }
}


proc makeIso { grave } {
# grave=0  iso seulement, grave=1 iso, puis gravure
global param projet
    if {$grave==1} {
      set param(iso) ""
    } else  {       
       set types {
         {{Text Files}       {.iso}        }
         {{All Files}        *             }
       }
       
       set param(iso) [tk_getSaveFile -title "Enregistrement de l'image iso " -filetypes $types -parent .]  
    }
    #destroy .select
    set option ""
    if {$param(multi)} {
      exec $param(cdrecord) -msinfo dev=$param(grav) >& burn.log
     
      set id [open burn.log "r"]
      gets $id ligne
      close $id
      set t [string first "," $ligne]
            
      set t1 [string first [string range $ligne 0 0] "0123456789"]
      if { ($t1>-1) && ($t>0)} {
        
        set option "-C $ligne -M"
        #tk_messageBox -icon info -message "t1:$t1 t:$t \n option:($option) " -title "Debug:" -parent . -type ok
      }
            
    }
    
    getdatalist
    
    enable_bt disabled
  
    if {$grave !=1} { ;# Creation d'iso
      set cmde " $param(mkisofs)  -no-bak -v -R -r -J -V \"$param(nom_iso)\" $option -o $param(iso) -graft-points $projet(dlist) "
      set pipe [open "| $param(mkisofs)  -no-bak -v -R -r -J -V \"$param(nom_iso)\" $option -o $param(iso) -graft-points $projet(dlist) " r+]
     
      enable_bt disable
      
      .res.result delete @0,0 end
      .res.result insert 0.0 $cmde
        catch { fileevent $pipe readable [list litpipe $pipe .res.result mkiso] } fid
      #catch {eval $cmde }
      .res.result insert 0.0 "\n Création iso terminé"
        
    }  else   { ;# Gravure à la volée:
    # Prépare la ligne de commande de creation d'iso qui sera envoyé directement à cdrecord par un pipe
    
      set param(cmde) " $param(mkisofs)  -no-bak -v -R -r -J  $option  -graft-points $projet(dlist) " 
      fenGravure 0
   
    }
  
   
    enable_bt active
    
   
 	
}

proc BurnAudio {} {
  global param
    
    #set newdata [tk_getOpenFile -initialdir "./" -parent . -filetypes $types -multiple true ]    
    
    if {$projet(dlist)!=""}  {
  # a remplacer par cdrdao ?  
	set cmde " $param(cdrecord) -v -speed=$param(speed) -dev=$param(grav) -pad -dao -audio $projet(dlist)"
	.res.result insert 0.0 "$cmde \n"
      set pipe [open "| $cmde " ]
    
      fileevent $pipe readable [list HandleProgramOutput $pipe .res.result]
	catch { close $f }
      tk_messageBox -icon info -message "Gravure terminée" -title "" -parent . -type ok

   }
 	#destroy .select
}

proc litpipe {f text mode} {
    switch $mode {
      "graveD" {set msg "Gravure terminée !"}
      "erase" {set msg "Effacement terminé"}
      "mkiso" {set msg "Création d'image terminée"}
      default {set msg " FIN " }
    }
    set l [gets $f]
    if {[eof $f]} {
      .res.result insert end "$l\n"
      $text yview moveto 1.0
      update idletasks
      fileevent $f readable {}
      catch { close $f }
        .res.result insert 0.0 "\n$msg"
       # if {$mode=="erase"} 
          tk_messageBox -icon info -message "$msg" -title "FIN" -parent . -type ok
        
        
        enable_bt active
              
    } else {
        $text insert end "$l\n"
        $text yview moveto 1.0
        if {[string first "Fixating time:" $l] >-1 } {
         #  tk_messageBox -icon info -message "$msg" -title "FIN" -parent . -type ok        
        }       
        #update ;#idletasks
    }
}

proc CopieCd {} {
global param
# Pour voir si le cd est vierge:
# cdrdao disk-info --device  $param(grav) 

    if {$param(lect)==$param(grav)} {
      set res [tk_messageBox -icon info -message "Vous n'avez pas spécifié de lecteur source\n Voulez vous le faire maintenant ?\n Si vous n'avez qu'un graveur et pas de lecteur cliquez non." -title "" -parent . -type yesno]
      if {$res=="yes"} {
        setup
        return
      }
      .res.result insert 0.0 "\nAucun lecteur source n'est configuré "
      set res [tk_messageBox -icon info -message "Veuillez insérer le CD source dans le graveur afin d'en faire une copie sur le disque dur" -title "" -parent . -type okcancel]
      if {$res=="no"} { return }
      
      set cmde "$param(cdrdao) read-cd --device $param(grav) --datafile image.raw image.toc"
        catch { eval $cmde }
      set cmde "$param(cdrdao) copy --device $param(grav)"
    } else  {
    
	set cmde "exec $param(cdrdao) copy --source-device $param(lect) --device $param(grav) --speed $param(speed) --on-the-fly >& $param(logfile)"
	catch { eval $cmde }
 	
    }
   .res.result insert 0.0 "\n$cmde"
   
}


init