#!/usr/bin/perl
# $Id: drakcronat,v 1.124 2005/05/27 12:16:29 oblin Exp $
#
# Mandrake Cron/At config tool
#
# Copyright (C) 2002-2004 MandrakeSoft
#                         Thierry K
#                         Thierry Vignaud <tvignaud@mandrakesoft.com>
#
# This program 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, or (at your option)
# any later version.
#
# This program 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 this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
###############################################################################

use strict;
use lib qw(/usr/lib/libDrakX);
use common;
use standalone;
use interactive;

#---
# i18n :
# IMPORTANT to get correct namespace (drakcronat instead of libDrakX)
#---
BEGIN { unshift @::textdomains, 'drakcronat' };

use ugtk2 qw(:create :helpers :wrappers);
use Gtk2::Deprecated;


#Global variables#
my (@tabuser, @tabdec, @tabtemp);
my @userallow;
my @userdeny;
my %calendar_data; # BUG: only window and settings get ever setted to non undef, but nothing is reused
my $window;
my $atboolmail = 1;
my $fselect;
my ($addcount, $ataddcount) = (0, 0);
my ($idd, $indic) = ("", "");
my $row;
my $lig;
my $column;
my $atoptlv;
my $Clspool;
my $edtlevel;
my ($indice, $ncron) = 0; #BUG
my ($status, $fname, $req);

my $file_allow   = "/etc/cron.allow";
my $file_deny    = "/etc/cron.deny";
my $atfile_allow = "/etc/at.allow";
my $atfile_deny  = "/etc/at.deny";
my $cronattemp   = "/var/tmp/cronattemp";
my $usertemp     = "/var/tmp/usertemp";
my $sbin_cronat  = "/usr/X11R6/bin/drakcronat";
my $curtable     = "/var/spool/cron/";

my $root = (split(/x/, getpwuid(0)))[0];

my $in;

$ugtk2::wm_icon = "drakcronat";


sub toggle_init($) {
    my ($tgglebut) = @_;
    if ($> == 0) {
        #$tgglebut->destroy;
        $tgglebut->child->set(N("USER MODE"));
    } else {
        defined $tgglebut and $tgglebut->child->set(N("ROOT MODE"));
    }
}

sub exec_with_user() {
    my $popup = Gtk2::Dialog->new;
    my $scroll = Gtk2::ScrolledWindow->new(undef, undef);
    $popup->set_size_request(200,150);
    $popup->set_position('center');
    $popup->signal_connect(delete_event => sub { ugtk2->exit(0) });
    $popup->set_title(N("Normal Users"));
    $popup->set_modal(1);
    $scroll->set_policy('never', 'automatic');
    my $clist_user = Gtk2::CList->new(1);
    $scroll->add($clist_user);

    $clist_user->append($_) foreach sort(list_users());
    my $box = Gtk2::HButtonBox->new;
    $popup->action_area->pack_start($box,0,0,0);

    my $button_ok = Gtk2::Button->new(" " . N("OK") . " ");
    my $usr;
    $clist_user->signal_connect(select_row => sub { 
                                    my ($clist_user, $urow, $column) = @_;
                                    $usr = $clist_user->get_text($urow, $column);
                                });

    $button_ok->signal_connect(clicked => sub { exec("su -m -l -c $sbin_cronat $usr") });
    $box->add($button_ok);

    my $button_cancel = Gtk2::Button->new(N("Cancel"));
    $button_cancel->signal_connect(clicked => sub { $popup->destroy });
    $box->add($button_cancel);

    $popup->vbox->pack_start($scroll, 1, 1, 0);
    $clist_user->set_selection_mode('single');
    $popup->show_all;
}

sub toggle_button_event() {
    if ($> == 0) {
        exec_with_user();
    } else {
        require_root_capability();
    }
}

sub calendar_changed($) {
    my ($Calend) = @_;
    my @months = 1..12;
    my ($day, $month, $year) = $Calend->get_date;
    "$year.$months[$month].$day";
}


sub initcron {
    my ($cbf, $cbcd, $_txtent) = @_;
    $cbcd->set_text("");
    $cbf->set_text("");
}

sub execute_at_command {
    my ($widget, $atrequeststr, $widget2) = @_;
    my $atrequestdt = $atrequeststr;
    $atrequeststr =~ s/((.*)\n){1}//m;
    $atrequestdt =~ s/(.*)(\n){1}/$1/m;
    my @op = split /\s/, $1;
    shift(@op) foreach 0..3;
    output($cronattemp, $atrequeststr);
    my $bMl = '-m' if $widget2->get_active;
    system("at $atoptlv $bMl @op -f $cronattemp rm -f $cronattemp");
    $ataddcount = 0;
    $atboolmail = 1;
    gtkset_sensitive($widget, 0);
}



sub parser {
    my ($arg, $user) = @_;
    my $string;
    if ($arg) {
        $string = `crontab -l` if $user eq $root;
        $string = `crontab -u $user -l` if $user ne "";
    } else {
        $string = `crontab -l`;
    }
    while ($string =~ s/((#.*)(\n))//m) {
        $string =~ s/((\n)(#.*))//m;
    }
#        @tabcmd = split /\n/, $string;
    return split /\n/, $string;
}

sub position {
    my ($lastelem, $arg) = @_;
    $lastelem =~ s/\*/\\*/g;
    my $cmdlig = `grep -n '$lastelem' $arg`;
    return (split /:/, $cmdlig)[0];
}

sub execute_crontab_command {
    my ($allcmd, $userr) = @_;
    $addcount = 0;
    #    standalone::explanations("Opening file ");
    if ($> == 0) {
        if ($userr ne "") {
            output($cronattemp, join("\n", @$allcmd));
            if ($userr eq $root) {
                return system("crontab $cronattemp; rm -f $cronattemp") ? 1 : 0;
            } else {
                return system("crontab -u $userr $cronattemp; rm -f $cronattemp") ? 1 : 0;
            }
        }
    } else {
        output($cronattemp, join("\n", @$allcmd));
        return system("crontab $cronattemp; rm -f $cronattemp") ? 1 : 0;
    }
}

sub initat {
    my ($atcbf, $atcbcd, $attxtent) = @_;
    $atcbcd->set_text("");
    $atcbf->set_text("");
    $attxtent->backward_delete($attxtent->get_length);
}

sub test_sensitive_delete {
    my ($bdelete, $ttxt) = @_;
    my $tamp;
    $tamp = $ttxt->get_chars(0, -1);
    gtkset_sensitive($bdelete, $tamp eq '' ? 0 : 1);
}

sub current_cronfile_delete {
    my ($fdel, $arg) = @_;
    #root mode
    $arg =~ s/\*/\\*/g;
    if ($> == 0 && $fdel ne "") {
        my $remove = $fdel eq $root ? `crontab -l` : `crontab -u $fdel -l`;
        $remove =~ s/($arg)\n//g;
        output($cronattemp, $remove);
        system(join('', "crontab,", if_($fdel eq $root, " -u $fdel "), $cronattemp));
        system("rm -f $cronattemp");
    } else {    #user mode
        my $remove = `crontab -l`;
        $remove =~ s/($arg)\n//g;
        output($cronattemp, $remove);
        system("crontab $cronattemp; rm -f $cronattemp");
    }
}

sub crEditStar($) {
    my ($w) = @_;
    $w->set_text('*');
}

sub spool_file_cron {
    my ($file, $allow, $username) = @_;
    $ncron = 0;

    if ($> == 0) {
        foreach my $fle (@$file) {
            foreach (parser(1, $fle)) {
                $Clspool->insert($indice, "CRON", $ncron, '""', '""', '""', '""', $fle);
                $indice++;
                $ncron++;
            }
            $ncron = 0;
        }
    } elsif ($allow == 0) {
        my @st = parser(0, "");
        foreach (@st) {
            next if $st[$ncron] eq "";
            $Clspool->insert($indice, "CRON", $ncron, '""', '""', '""', '""', $username);
            $indice++;
            $ncron++;
        }
    }
}

sub set_view {
    my ($view, $filename, $ind) = @_;
    my @string;
    $view->backward_delete($view->get_length);
    if ($> == 0) {
        @string = parser(1, $filename);
    } else {
        @string = parser(0, "");
    }
    $view->insert(undef, $view->style->black,undef, $string[$ind]);
}

sub at_set_view {
    my ($at_view, $ids) = @_;
    my $string = `at -c "$ids"`;
    $string =~ s/(.*\}\n){1}//m;
    $at_view->backward_delete($at_view->get_length);
    $at_view->insert(undef, $at_view->style->black,undef, $');
}


sub clock_init {
    my ($Hour, $Min) = @_; # BUG: unused
    my @clock = split /:/, `date +%H:%M`;
    $Hour->set_value($clock[0]);
    $Min->set_value($clock[1]);
}

sub calendar_init($) {
    my ($w) = @_;
    my @date;
    @date = split /:/, `date +%d:%m:%Y`;
    $w->select_month($date[1]-1, $date[2]);
    $w->select_day($date[0]);
    $w->mark_day($date[0]);
}

sub check_mail {
    my ($ckmail, $crml) = @_;
    if ($ckmail->active) {
        $crml->set_text("");
        $crml->set_editable(1);
    } else {
        $crml->set_text('""');
        $crml->set_editable(0);
    }
}

sub spool_modify {
    my ($nid, $tspll, $ttx, $_level, $nuser, $stat) = @_;
    my $string = `at -c "$nid"`;
    $string =~ s/(.*\}\n){1}//m;
    $string = $';
    my $modbx = Gtk2::VBox->new(0,0);
    $modbx->set_border_width(30);
    my $modif = gtkset_modal(Gtk2::Window->new, 1);
    $modif->set_title(N("Task Modification"));
    $modif->set_size_request(-1, -1);
    gtkadd($modif,
           gtkpack__($modbx, 
                     my $bclock = Gtk2::Button->new(N("Change time")), 
                     my $bcmd = Gtk2::Button->new(N("Change command")),
                     my $cancel = Gtk2::Button->new(N("Cancel"))));
    $cancel->signal_connect(clicked => sub { 
                                $modif->destroy;
                            });

    ###################   Time modification    ############################################################
    $bclock->signal_connect(clicked => sub {
                                my $timef = gtkset_modal(Gtk2::Window->new, 1);
                                $timef->set_title(N("Time modification"));
                                $timef->set_size_request(-1, -1);
                                my $ntext = Gtk2::Text->new(undef, undef);
                                $ntext->set_editable(1);
                                $ntext->insert(undef, $ntext->style->black,undef, $string);
                                my $vbox2 = Gtk2::VBox->new;
                                my $hbox = Gtk2::HBox->new;
                                my $adjTH = Gtk2::Adjustment->new(0,0,23,1,1,0);
                                my $adjTM = Gtk2::Adjustment->new(0,0,59,1,1,0);
                                my $framedate = Gtk2::Frame->new(N("Time parameters"));
                                my $frameperd = Gtk2::Frame->new(N("Periodic task"));
                                my $framef = Gtk2::Frame->new(N("Options"));
                                $calendar_data{window} = undef;
                                $calendar_data{font} = undef;
                                $calendar_data{font_dialog} = undef;
                                $calendar_data{settings} = [ 0, 0, 0, 0, 0 ];
                                my $mCalendar = Gtk2::Calendar->new;
                                $calendar_data{window} = $mCalendar;

                                gtkpack__($vbox2,
                                          gtkpack($hbox,
                                                  gtkadd(gtkset_border_width($framedate, 2),
                                                         gtkpack_(Gtk2::VBox->new,
                                                                  1, gtkpack_(gtkset_border_width(Gtk2::HBox->new, 0),
                                                                              1, Gtk2::Label->new(N("Hour:")),
                                                                              1, my $mbHH = Gtk2::SpinButton->new($adjTH, 0.0,0),
                                                                              1, Gtk2::Label->new(N("Minute:")),
                                                                              1, my $mbMM = Gtk2::SpinButton->new($adjTM, 0.0,0)),
                                                                  1, gtkpack_(gtkset_border_width(Gtk2::HBox->new, 2),1, $mCalendar)
                                                                 )),
                                                  
                                                  gtkadd(gtkset_border_width($frameperd, 2),
                                                         create_packtable({ col_spacings => 2, row_spacings => 2 },
                                                                          [ my $chckper = Gtk2::CheckButton->new(N("Activate")),
                                                                          ],
                                                                          [ Gtk2::Label->new(N("Hour:")),
                                                                            gtkset_sensitive(my $mcrbHH = Gtk2::Entry->new, 0),
                                                                            my $allH = Gtk2::Button->new(N("_:all hours\nAll")),
                                                                          ],
                                                                          [ Gtk2::Label->new(N("Minute:")),
                                                                            gtkset_sensitive(my $mcrbMM = Gtk2::Entry->new, 0),
                                                                            my $allM = Gtk2::Button->new(N("_:all minutes\nAll")),
                                                                          ],
                                                                          [ Gtk2::Label->new(N("Months:")),
                                                                            gtkset_sensitive(my $mcrm = Gtk2::Entry->new, 0),
                                                                            my $ballm = Gtk2::Button->new(N("_:all months\nAll")),
                                                                          ],
                                                                          [ Gtk2::Label->new(N("Day of Week:")),
                                                                            gtkset_sensitive(my $mcrdwk = Gtk2::Entry->new, 0),
                                                                            my $balldwk = Gtk2::Button->new(N("_:all weeks\nAll")),
                                                                          ],
                                                                          [ Gtk2::Label->new(N("Day of Month:")),
                                                                            gtkset_sensitive(my $mcrdm = Gtk2::Entry->new, 0),
                                                                            my $balldm = Gtk2::Button->new(N("_:all days of month\nAll")),
                                                                          ],
                                                                         ),
                                                        ),
                                                  
                                                 )
                                          , gtkpack_(Gtk2::VBox->new(0,0),
                                                     0, gtkpack_(Gtk2::VBox->new(0,0),
                                                                 1, gtkadd(gtkset_border_width($framef, 5),
                                                                           gtkpack_(Gtk2::HBox->new(0,0),
                                                                                    0, Gtk2::Label->new(N("Spool level:")),
                                                                                    0, my $matlevelt = Gtk2::Entry->new,
                                                                                    0, gtkset_active(my $mail = Gtk2::CheckButton->new(N("Mail")), 0),
                                                                                    0, gtkset_sensitive(my $mmailentry = Gtk2::Entry->new, 0)
                                                                                   )))),
                                          gtkpack_(Gtk2::HBox->new(0,0),0, my $tapply = Gtk2::Button->new(N("Apply")),0, my $tcancel = Gtk2::Button->new(N("Cancel")))
                                         );

                                $vbox2->show_all;
                                $timef->add($vbox2);
                                my @mentryp = ($mmailentry, $mcrbHH, $mcrbMM, $mcrm, $mcrdwk, $mcrdm);
                                my @mentry = ($mCalendar, $mbHH, $mbMM, $matlevelt);


                                ######   TIME  SIGNALS  ########
                                my $retour = ();
                                $tapply->signal_connect(clicked => sub {
                                                            if ($chckper->get_active) { # CRON enabled#
                                                                my $Cmdchars = $ttx->get_chars(0, -1);
                                                                $retour = get_time_change(1, $stat, $mcrbHH, $mcrbMM, $mcrm, $mcrdwk, $mcrdm, "", $Cmdchars, $nuser, $tapply);
                                                            } else { # AT enabled#
                                                                my $Cmdchars = $ttx->get_chars(0, -1);
                                                                $retour = get_time_change(0, $stat, $mCalendar, $mbHH, $mbMM, $matlevelt, $mail, $Cmdchars, $nuser, $tapply);
                                                                delete_spool($ttx) if $stat eq 'AT';
                                                            }
                                                            $ttx->insert(undef, $ttx->style->black,undef, N("Operation succeeded")) unless $retour;


                                                            get_logname(0, $nuser);
                                                            $timef->destroy;
                                                            $modif->destroy;
                                                        });

                                $tcancel->signal_connect(clicked => sub { $timef->destroy });
                                $mail->signal_connect(toggled => sub {
                                                          if ($mail->get_active) {
                                                              if ($chckper->get_active) {
                                                                  $mmailentry->set_text("");
                                                                  gtkset_sensitive($mmailentry, 0);
                                                              } else {
                                                                  $mmailentry->set_text(N("You will receive a mail"));
                                                              }
                                                          }
                                                          return unless $mail->get_active;
                                                          if ($chckper->get_active) {
                                                              $mmailentry->set_text('""');
                                                              gtkset_sensitive($mmailentry, 0);
                                                          } else {
                                                              $mmailentry->set_text("");
                                                          }
                                                      });

                                $chckper->signal_connect(toggled => sub { 
                                                             init_frame($chckper->get_active ? 1 : 0, $mail, \@mentryp, \@mentry);
                                                         });

                                $allH->signal_connect(clicked => sub { crEditStar($mcrbHH) });
                                $allM->signal_connect(clicked => sub { crEditStar($mcrbMM) });
                                $balldm->signal_connect(clicked => sub { crEditStar($mcrdm) });
                                $balldwk->signal_connect(clicked => sub { crEditStar($mcrdwk) });
                                $ballm->signal_connect(clicked => sub { crEditStar($mcrm) });


                                ######   INITIALISATION    ##########
                                my $allow = get_logname(0, $nuser);
                                if ($allow == -1) {
                                    $in ||= interactive->vnew;
                                    $in->ask_warn(N("WARNING"), N("You are not allowed to modify this task"));
                                    $timef->destroy;
                                    $modif->destroy;
                                } else {
                                    #CRON
                                    if ($allow == 0) {
                                        gtkset_active($chckper, 1);
                                        gtkset_sensitive($chckper, 0);
                                    } elsif ($allow == 1) { #AT
                                        gtkset_active($chckper, 0);
                                        gtkset_sensitive($chckper, 0);
                                    } elsif ($allow == 2) { #CRON AND AT
                                        gtkset_active($chckper, 1);
                                        gtkset_sensitive($chckper, 1);
                                    }
                                }


                                if ($status eq "AT") {
                                    gtkset_active($chckper, 0);
                                    gtkset_sensitive($chckper, 0);
                                    my @spd  = split /-/, $tspll->get_text($lig, 3);
                                    my @hour = split /:/, $tspll->get_text($lig, 4);
                                    $mCalendar->select_month($spd[1]-1, $spd[0]);
                                    $mCalendar->select_day($spd[2]);
                                    $mbHH->set_value($hour[0]);
                                    $mbMM->set_value($hour[1]);
                                } else {
                                    gtkset_active($chckper, 1);
                                }

                                gtkset_sensitive($chckper, 0) if $> == 0 && $nuser ne $root;

                                $timef->set_position('center');
                                $timef->show_all;
                            });

    ##################   END Time modification   ########################################################


    $bcmd->signal_connect(clicked => sub {
                              my $cmdf = gtkset_size_request(gtkset_modal(Gtk2::Window->new, 1), -1, -1);
                              $cmdf->set_title(N("Command modification"));
                              my $attext = gtkset_editable(Gtk2::Text->new(undef, undef), 1);
                              my ($oldstr, $cronclock);
                              if ($stat eq "AT") { 
                                  $attext->insert(undef, $attext->style->black,undef, $string);
                              } else {
                                  my $parsecmd = $ttx->get_chars(0, -1);
                                  $oldstr =  $ttx->get_chars(0, -1);
                                  $parsecmd =~ s/(...)\s(..){3}//m;
                                  my $newstr = $';
                                  $cronclock = $&;
                                  $attext->insert(undef, $attext->style->black,undef, $newstr);
                              }

                              my $atvscrollbar = Gtk2::VScrollbar->new($attext->vadj);
                              my $atcmhbox = Gtk2::HBox->new(0,0);
                              $atcmhbox->set_border_width(5);
                              gtkadd($cmdf, gtkpack_(Gtk2::VBox->new(0,0),0, gtkpack_(Gtk2::HBox->new(0,0),1, $attext,0, $atvscrollbar),
                                                     0, gtkset_active(my $mail = Gtk2::CheckButton->new(N("Receive the report of execution")), 0),
                                                     0, gtkpack_(Gtk2::HBox->new(0,0),0, my $capply = Gtk2::Button->new(N("Apply")),0, my $ccancel = Gtk2::Button->new(N("Cancel")))));
                              ###########  COMMAND SIGNALS   #######
                              $capply->signal_connect(clicked => sub {
                                                          my $string = $attext->get_chars(0, -1);
                                                          my $strsource = $ttx->get_chars(0, -1);
                                                          my $retour = get_command_change($tspll, $mail, $string, $stat, $cronclock, $nuser, $strsource, $capply, $oldstr);
                                                          unless ($retour) {
                                                              delete_spool($ttx);
                                                              $ttx->insert(undef, $ttx->style->black,undef, N("Operation succeeded"));
                                                              #spool_table_refresh($level,1);
                                                          }
                                                          get_logname(0, $nuser);
                                                          $cmdf->destroy;
                                                          $modif->destroy;
                                                      });
                              $ccancel->signal_connect(clicked => sub { $cmdf->destroy });
                              ######################################
                              
                              gtkset_sensitive($mail, 0) if $stat eq 'CRON';
                              $cmdf->set_position('center');
                              $cmdf->show_all;
                          });
    $modif->set_position('center');
    $modif->realize;
    $modif->show_all;
}

sub get_command_change {
  my ($text, $w1, $str, $sys, $w4, $nuser, $_w6, $capply, $oldstr) = @_;
    chomp($str);
    my $tmerequ;
    if ($sys eq "AT") {
        my @spd  = split /-/, $text->get_text($lig,3);
        my $date = "$spd[2].$spd[1].$spd[0]";
        my $hour = $text->get_text($lig,4);
        my $level = $text->get_text($lig,5);
        my $mail = $w1->get_active;
        $tmerequ = "at ";
        $tmerequ .= "-m " if $mail;
        $tmerequ .= "-q $level $hour $date";
    } else {
        $tmerequ = $w4;
    }
    return change($sys, $tmerequ, $str, $capply, $nuser, $oldstr);
}

my $pos;

sub change {
  my ($sys, $cmd, $string, $_capply, $nuser, $oldstr) = @_;
    if ($sys eq "AT") {
        output($cronattemp, $string);
        return system("$cmd -f $cronattemp; rm -f $cronattemp") == 0 ? 0 : 1;
    } else {
        my @parse = parser($> == 0 ? 1 : 0, $nuser);
        my $reqst = "$cmd$string";
        replace_cmd(\@parse, $oldstr, $reqst);
        return execute_crontab_command(\@parse, $nuser, $pos) ? 1 : 0;
    }
}


sub get_time_change {
    if ($_[0]) {                #  CRON  #
        my $parsecmd = $_[8];
        $parsecmd =~ s/(...)\s(..){3}//m;
        my $Hvaluecr = $_[2]->get_text;
        my $Mvaluecr = $_[3]->get_text;
        my $Mthvaluecr = $_[4]->get_text;
        my $DoWvaluecr = $_[5]->get_text;
        my $DoMvaluecr = $_[6]->get_text;
      SWITCH: {  $Hvaluecr = '*', if $Hvaluecr eq "";
                 $Mvaluecr = '*', if $Mvaluecr eq "";
                 $Mthvaluecr = '*', if $Mthvaluecr eq "";
                 $DoWvaluecr = '*', if $DoWvaluecr eq "";
                 $DoMvaluecr = '*', if $DoMvaluecr eq "";
             }
        my $time = "$Mvaluecr $Hvaluecr $Mthvaluecr $DoWvaluecr $DoMvaluecr ";

        return change($_[1], $time, $parsecmd, $_[10], $_[9], $_[8]);
    } else {                    # AT enabled
        # CRON->AT ou AT -> AT
        my $newstr;
        my $Date = calendar_changed($_[2]);
        my $Hvalueat = $_[3]->get_value_as_int;
        my $Mvalueat = $_[4]->get_value_as_int;
        my $SpEntry = $_[5]->get_text;
        my $atMail = $_[6]->get_active;
        my $tmerequ = "at";
        $tmerequ = "$tmerequ -m " if $atMail;
        $SpEntry = $_[5]->get_text;
        $SpEntry = 'a' if $SpEntry eq "";
        $tmerequ = "$tmerequ -q $SpEntry ";
        $tmerequ = "$tmerequ$Hvalueat:";
        $tmerequ = " $tmerequ$Mvalueat ";
        $tmerequ = "$tmerequ$Date ";
        chomp($tmerequ);
        if ($_[1] eq "CRON") {  #CRON->AT
            my $parsecmd = $_[7];
            $parsecmd =~ s/(...)\s(..){3}//m;
            current_cronfile_delete($_[8], $_[7]);
            chomp($newstr = $');
            return change("AT", $tmerequ, $newstr, $_[9], $_[8], $_[7]);
        } else {
            chomp($newstr = $_[7]);
            return change($_[1], $tmerequ, $newstr);
        }
    }
}

sub replace_cmd {
    my ($parse, $comp, $new) = @_;
    my $i = 0;
    foreach my $org (@$parse) {
        if ($org eq $comp) {
            $parse->[$i] = $new;
            last;
        }
        $i++;
    }
}

sub spool_table_refresh {
    my ($level, $allow) = @_;
    my @fspool;
    my $request;
    if ($allow == 1) {
        $request = $level->get_text;
        if ($request ne '') {
            @fspool  = split /\n/, `atq -q $request`;
        } else {
            @fspool  = split /\n/, `atq`;
        }
        foreach my $temp (@fspool) {
            $Clspool->insert($indice, "AT", '""', split /\s/, $temp);
            $indice++;
        }
    }
}

sub delete_spool($) {
    my ($w) = @_;
    $w->backward_delete($w->get_length);
    system("atrm $idd") unless $idd eq "";
}

sub file_open($) {
    $fselect = Gtk2::FileSelection->new(N("File"));
    my ($fboxsel) = @_;
    $fselect->ok_button->signal_connect(clicked => sub {
                                            $fboxsel->set_text($fselect->get_filename);
                                            $fselect->destroy;
                                        });
    $fselect->cancel_button->signal_connect(clicked => sub { $fselect->destroy });
    $fselect->show;
}


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

# Creation of the main frame
my $w = ugtk2->new('drakcronat');
$window = $w->{window};
unless ($::isEmbedded) {
    $w->{rwindow}->set_size_request(-1, -1);
    $w->{rwindow}->set_position('center');
    $w->{rwindow}->set_title(N("DrakCronAt"));
}
$window->signal_connect(delete_event => \&quit_global);


#############################################   MAIN   #####################################

my $tableat = Gtk2::Table->new(10,10, 0);
$tableat->set_row_spacing(0, 2);
$tableat->set_col_spacing(0, 2);
my $framespool = Gtk2::Frame->new(N("View"));
gtkset_border_width($framespool, 5);
my $frameresume = Gtk2::Frame->new(N("Resume"));
gtkset_border_width($frameresume, 5);
$framespool->add($tableat);
gtkshow($_) foreach $framespool, $frameresume;

########################## Nouvelle partie ##################

my $usercboxat = Gtk2::OptionMenu->new;
my $userlabelat = Gtk2::Label->new(N("User: "));
$tableat->attach($usercboxat,1,2,0,1, ['fill'], ['fill'],0,0);
$tableat->attach($userlabelat,0,1,0,1, ['shrink', 'fill'], ['shrink', 'fill'],0,0);
get_name();
my @titles;
@titles = (N("Status"), N("Task #"), N("ID"), N("Date"), N("Hour"), N("Level"), N("User"));
my $readjust = Gtk2::Label->new("         ");
$Clspool = new_with_titles  Gtk2::CList(@titles);
$Clspool->column_titles_passive;
for (my $i = 0; $i < 8; $i++) {
    $Clspool->set_column_resizeable($i, 0);
}
$Clspool->set_column_width(0,40);
$Clspool->set_column_width(1,50);
$Clspool->set_column_width(2,40);
$Clspool->set_column_width(3,70);
$Clspool->set_column_width(4,50);
$Clspool->set_column_width(5,50);
$Clspool->set_column_width(6,50);

my $labelspool = Gtk2::Label->new(N("Spool level:"));
$tableat->attach($readjust,9,10,9,10, ['fill'], ['fill'],0,0);
$tableat->attach($labelspool,2,3,0,1, ['fill'], ['fill'],0,0);
gtkpack(my $levelbox = Gtk2::HBox->new(0,0), $edtlevel = Gtk2::Entry->new, my $refreshb = Gtk2::Button->new(N("Refresh")));
$tableat->attach($levelbox,3,4,0,1, ['fill'], ['fill'],0,0);
$refreshb->signal_connect(clicked => sub {
                              my $str =  $usercboxat->entry->get_text;
                              get_logname(0, $str);
                          });

my $textmain = Gtk2::Text->new(undef,undef);
my $vscrollmain = Gtk2::VScrollbar->new($textmain->vadj);
gtkadd($frameresume, gtkpack_(Gtk2::HBox->new,1, $textmain,0, $vscrollmain));
$textmain->set_editable(0);
$frameresume->show_all;

my $scrolled_window = Gtk2::ScrolledWindow->new(undef, undef);
$tableat->attach($scrolled_window,1,4,4,5, ['expand', 'shrink', 'fill'], ['expand', 'shrink', 'fill'],0,0);
$scrolled_window->set_policy('automatic', 'always');
$scrolled_window->add($Clspool);
gtkpack(my $boxspool = Gtk2::HBox->new(0,0), my $addtask = Gtk2::Button->new(N("Add")), my $deleteb = Gtk2::Button->new(N("Delete")), my $attogact = Gtk2::Button->new(N("Modify"))); #, my $deactiv = Gtk2::Button->new(N("Deactivate")));
$tableat->attach($boxspool,1,4,5,6, ['fill'], ['fill'],0,0);
gtkset_sensitive($deleteb, 0);
gtkset_sensitive($attogact, 0);


$addtask->signal_connect(clicked => sub {
                             my $string = $usercboxat->entry->get_text;
                             my $allow = get_logname(0, $string);
                             if ($allow == -1) {
                                 $in ||= interactive->vnew;
                                 $in->ask_warn(N("WARNING"), N("You are not allowed to add a new task"));
                             } else {
                                 if ($> == 0 && $string ne $root) {
                                     newtask(0, $string);
                                 } else {
                                     newtask($allow, $string);
                                 }
                             }
                         });


$Clspool->signal_connect(select_row => sub {
                             my ($Clspool, $row) = @_;
                             $lig = $row;
                             $indic = $Clspool->get_text($row,1);
                             $status = $Clspool->get_text($row,0);
                             $fname = $Clspool->get_text($row,6);
                             if ($status eq "AT") {
                                 $idd = $Clspool->get_text($row,2);
                                 at_set_view($textmain, $idd);
                                 gtkset_sensitive($deleteb, 1);
                                 if ($> ==  0) {
                                     gtkset_sensitive($attogact, $root eq $fname ? 1 : 0);
                                 } else {
                                     gtkset_sensitive($attogact, 1);
                                 }
                             } else {
                                 set_view($textmain, $fname, $indic);
                                 gtkset_sensitive($deleteb, 1);
                                 gtkset_sensitive($attogact, 1);
                             }
                         });
  
  $Clspool->signal_connect(unselect_row => sub {
                               gtkset_sensitive($deleteb, 0);
                               gtkset_sensitive($attogact, 0);
                           });
  

$deleteb->signal_connect(clicked => sub {
                             delete_spool($textmain) if $status eq "AT";
                             current_cronfile_delete($fname, $textmain->get_chars(0, -1)) if $status eq "CRON";
                             gtkset_sensitive($deleteb, 0);
                             my $str =  $usercboxat->entry->get_text;
                             get_logname(0, $str);
                             $textmain->backward_delete($textmain->get_length);
                         });


$attogact->signal_connect(clicked => sub {
                              my $string = $usercboxat->entry->get_text;
                              spool_modify($idd, $Clspool, $textmain, $edtlevel, $fname, $status);
                          });


#Call timeout_add function for to refresh Spool Table
my $str =  $usercboxat->entry->get_text;
get_logname(0, $str);

$levelbox->show_all;
gtkshow($_) foreach $readjust, $Clspool, $labelspool, $boxspool, $deleteb, $attogact, $scrolled_window, $usercboxat, $userlabelat, $tableat;

sub newtask($) {
    my ($allow, $nuser) = @_;
    my $ntext = Gtk2::Text->new;
    $ntext->set_editable(1);
    $ntext->insert(undef, $ntext->style->black, undef, $nuser);
    my $atvscrollbar = Gtk2::VScrollbar->new($ntext->vadj);
    my $vbox2 = Gtk2::VBox->new;
    my $hbox = Gtk2::HBox->new;
    my $Newt = Gtk2::Window->new;
    my $adjTH = Gtk2::Adjustment->new(0,0,23,1,1,0);
    my $adjTM = Gtk2::Adjustment->new(0,0,59,1,1,0);
    $Newt->set_position('center');
    $Newt->set_title(N("New task"));
    $Newt->set_size_request(-1, -1);
    my $frameresume = Gtk2::Frame->new(N("Resume"));
    my $_framedate = Gtk2::Frame->new(N("Time parameters"));
    my $framecmd = Gtk2::Frame->new(N("Command"));
    my $frametime = Gtk2::Frame->new(N("Time"));
    my $frameperd = Gtk2::Frame->new(N("Periodic task"));
    $calendar_data{window} = undef;
    $calendar_data{font} = undef;
    $calendar_data{font_dialog} = undef;
    $calendar_data{settings} = [ 0, 0, 0, 0, 0 ];
    my $mCalendar = Gtk2::Calendar->new;
    $calendar_data{window} = $mCalendar;



    gtkpack__($vbox2,
              gtkadd(gtkset_border_width($frameresume, 2), gtkpack_(Gtk2::HBox->new,
                                                                                        1, $ntext,
                                                                                        0, $atvscrollbar)),
              gtkpack($hbox,
                      gtkadd(gtkset_border_width($frametime, 2),
                             gtkpack_(Gtk2::VBox->new,
                                      1, gtkpack_(gtkset_border_width(Gtk2::HBox->new, 0),
                                                  1, Gtk2::Label->new(N("Hour:")),
                                                  1, my $mbHH = Gtk2::SpinButton->new($adjTH, 0.0,0),
                                                  1, Gtk2::Label->new(N("Minute:")),
                                                  1, my $mbMM = Gtk2::SpinButton->new($adjTM, 0.0,0)),
                                      1, gtkpack_(gtkset_border_width(Gtk2::HBox->new, 2),1, $mCalendar)

                                     )),
                      gtkadd(gtkset_border_width($frameperd, 2),
                             create_packtable({ col_spacings => 2, row_spacings => 2 },
                                              [ my $chckper = Gtk2::CheckButton->new(N("Activate")),
                                              ],
                                              [ Gtk2::Label->new(N("Hour:")),
                                                gtkset_sensitive(my $mcrbHH = Gtk2::Entry->new, 0),
                                                my $allH = Gtk2::Button->new(N("_:all hours\nAll")),
                                              ],
                                              [ Gtk2::Label->new(N("Minute:")),
                                                gtkset_sensitive(my $mcrbMM = Gtk2::Entry->new, 0),
                                                my $allM = Gtk2::Button->new(N("_:all minutes\nAll")),
                                              ],
                                              [ Gtk2::Label->new(N("Months:")),
                                                gtkset_sensitive(my $mcrm = Gtk2::Entry->new, 0),
                                                my $ballm = Gtk2::Button->new(N("_:all months\nAll")),
                                              ],
                                              [ Gtk2::Label->new(N("Day of Week:")),
                                                gtkset_sensitive(my $mcrdwk = Gtk2::Entry->new, 0),
                                                my $balldwk = Gtk2::Button->new(N("_:all weeks\nAll")),
                                              ],
                                              [ Gtk2::Label->new(N("Day of Month:")),
                                                gtkset_sensitive(my $mcrdm = Gtk2::Entry->new, 0),
                                                my $balldm = Gtk2::Button->new(N("_:all days of month\nAll")),
                                              ],
                                             ),
                            ),
                     ),
              gtkset_border_width($framecmd, 2),
              gtkpack(create_hbox('edge'),
                      my $executeb = Gtk2::Button->new(N("Execute")),
                      my $quit = Gtk2::Button->new(N("Quit")),
                     ),
             );
    $vbox2->show_all;
    $Newt->add($vbox2);
    $quit->can_default(1);
    $quit->grab_default;
    $quit->show;
    $executeb->can_default(1);
    $executeb->grab_default;
    $executeb->show;
    gtkset_sensitive($executeb, 0);
    
    $framecmd->add(create_packtable({ col_spacings => 2, row_spacings => 2, },
                                    [ my $lv = Gtk2::Label->new(N("Spool level:")), my $matlevelt = Gtk2::Entry->new, ],
                                    [ gtkset_active(my $mail = Gtk2::CheckButton->new(N("Mail")), 0),
                                      gtkset_sensitive(my $mmailentry = Gtk2::Entry->new, 0), ],
                                    [ my $of = Gtk2::Label->new(N("Output file:")),
                                      gtkpack_(Gtk2::HBox->new(0,0),
                                               1, my $atfileout = Gtk2::Entry->new,
                                               0, my $atfobrowser = Gtk2::Button->new("...")
                                              ),
                                    ],
                                    [ my $Comm = Gtk2::Label->new(N("Command:")),
                                      gtkpack_(Gtk2::HBox->new(0,0),
                                               1, my $atcmdentry = Gtk2::Entry->new,
                                               0, my $atcmdfile = Gtk2::Button->new("..."),
                                               0, my $tskadd = Gtk2::Button->new(N("Add"))
                                              ),
                                    ],
                                   )
                  );

    $matlevelt->set_text('c');
    my @mentryp = ($mmailentry, $mcrbHH, $mcrbMM, $mcrm, $mcrdwk, $mcrdm);
    my @mentry = ($mCalendar, $mbHH, $mbMM, $matlevelt, $tskadd, $mail);
    $Newt->show_all;
    gtkshow($_) foreach $of, $Comm, $lv;

    ################     FIN Nouvelle Partie     ##############
    ##               Gestion des signaux                ##
    sub init_frame {
        my $fentry = $_[2];
        my $sentry = $_[3];
        if ($_[0] eq 1) {
            gtkset_sensitive($_, 1) foreach @$fentry;
            gtkset_sensitive($_, 0) foreach @$sentry;
            gtkset_sensitive(@$fentry[0], 0);
        } else {
            gtkset_sensitive($_, 0) foreach @$fentry;
            gtkset_sensitive($_, 1) foreach @$sentry;
            @$sentry[3]->set_text("c");
            @$fentry[0]->set_text($_[1]->get_active ? N("You will receive a mail") : "");
        }
    }

    $atcmdentry->signal_connect(changed => sub {     
                                    if ($chckper->get_active) {
                                        gtkset_sensitive($executeb, $atcmdentry->get_text eq "" ? 0 : 1);
                                    } else {
                                        gtkset_sensitive($executeb, $ntext->get_chars(0, -1) eq "" ? 0 : 1);
                                    }
                                });

    $mail->signal_connect(toggled => sub {
                              if ($mentry[5]->get_active) {
                                  if ($chckper->get_active) {
                                      gtkset_sensitive($mentryp[0], 0);
                                      gtkset_sensitive($mentry[5], 0);
                                  } else {
                                      $mentryp[0]->set_text("You will receive a mail");
                                  }
                              }
                              if (!$mentry[5]->get_active) {
                                  if (!$chckper->get_active) {
                                      $mentryp[0]->set_text("");
                                  } else {
                                      gtkset_sensitive($mentryp[0], 0);
                                      gtkset_sensitive($mentry[5], 0);
                                  }
                              }
                          });
    
    $chckper->signal_connect(toggled => sub { 
                                 if ($chckper->get_active) {
                                     gtkset_sensitive($executeb, $atcmdentry->get_text eq "" ? 0 : 1);
                                     init_frame(1, $mentry[5], \@mentryp, \@mentry);
                                 } else {
                                     gtkset_sensitive($executeb, $ntext->get_chars eq "" ? 0 : 1);
                                     init_frame(0, $mentry[5], \@mentryp, \@mentry);
                                 }
                             });
    
    $quit->signal_connect(clicked => sub { 
                              $Newt->destroy;
                          });


    $atcmdfile->signal_connect(clicked => sub { file_open($atcmdentry) });
    $atfobrowser->signal_connect(clicked => sub { file_open($atfileout) });
    $executeb->signal_connect(clicked => sub {
                                  my @parse;
                                  my $mode = $chckper->get_active;
                                  if (!$mode) {
                                      $req = $ntext->get_chars(0, -1);
                                      execute_at_command($executeb, $req, $mail);
                                  } else {
                                      add_command_button($ntext, $deleteb, $attogact, $executeb,
                                                         $mode, $mentryp[1], $mentryp[2], $mentryp[3], $mentryp[4], $mentryp[5], $atfileout, $atcmdentry);

                                      if ($> == 0) {
                                          @parse = parser(1, $nuser);
                                          my $lastelem = $parse[-1];
                                          my $userr; #BUG: never set
                                          $pos = $lastelem ne "" ? position($lastelem, "$curtable$userr") : -1;
                                      } else {
                                          @parse = parser(0, $nuser);
                                          my $lastelem = $parse[-1];
                                          if ($lastelem ne "") {
                                              my $reqst = `crontab -l`;
                                              output($usertemp, $reqst);
                                              $pos = position($lastelem, $usertemp);
                                          } else {
                                              $pos = -1;
                                          }
                                      }
                                      @parse = (@parse, $req);
                                       execute_crontab_command(\@parse, $nuser, $pos);
                                  }
                                  get_logname(0, $nuser);
                                  $Newt->destroy;
                              });

    $tskadd->signal_connect(clicked => sub {
                                my $mode = $chckper->get_active;
                                $addcount = 0;
                                $ataddcount = 0;
                                $atboolmail = 1;
                                add_command_button($ntext, $deleteb, $attogact, $executeb, $mode,
                                                   $mentry[1], $mentry[2], $mentry[0], $mentry[3], $atfileout, $atcmdentry);
                            });

    $allH->signal_connect(clicked => sub { crEditStar($mcrbHH) });
    $allM->signal_connect(clicked => sub { crEditStar($mcrbMM) });
    $balldm->signal_connect(clicked => sub { crEditStar($mcrdm) });
    $balldwk->signal_connect(clicked => sub { crEditStar($mcrdwk) });
    $ballm->signal_connect(clicked => sub { crEditStar($mcrm) });

    ###########   INITIALISATION    ##########################
    clock_init($mentry[1], $mentry[2]);
    calendar_init($mentry[0]);
    init_add_task($allow, $chckper);
    ###########      FIN INITIALISAITON


}

sub quit_global() {
    $window->destroy;
    ugtk2->exit;
    $in->exit(0) if $in;
}

##################################    ALL    ############################################################

#Creation of a toggle button
my $togglebutton = Gtk2::ToggleButton->new("");
$togglebutton->set_active(0);
toggle_init($togglebutton);
$togglebutton->signal_connect(clicked => sub { toggle_button_event() });

gtkadd($window,
       gtkpack(Gtk2::VBox->new,
               $framespool,
               $frameresume,
               gtkpack(create_hbox('edge'),
                       $togglebutton,
                       my $bquit = gtksignal_connect(Gtk2::Button->new(N("Close")),
                                                     clicked => \&quit_global),
                      ),
              ),
      );

$bquit->can_default(1);
$bquit->grab_default;

$window->show;

$w->main;
quit_global();

####################################  FUNCTIONS ##############################

sub warnmsg {
    my ($w) = @_;
    my $wbox = Gtk2::VBox->new(0,0);
    $wbox->set_border_width(10);
    gtkadd(my $warn = gtkset_modal(Gtk2::Window->new, 1),
           gtkpack($wbox, ($w), my $butt = Gtk2::Button->new(N("Ok"))));
    $butt->signal_connect(clicked => sub { $warn->destroy });
    $warn->set_position('center');
    $warn->realize;
    $warn->show_all;
}

sub get_name() {
    my @list_user = sort(list_users());
    if ($> == 0) {
        @list_user = ((split /x/, getpwuid(0))[0], @list_user);
        $usercboxat->set_popdown_strings(@list_user);
    } else {
        @tabuser = (split /x/, getpwuid($>))[0];
        $usercboxat->set_popdown_strings(@tabuser);
    }
}

sub user_logname_compare($) {
    my ($a) = @_;
    my @tabus;
    my $stat = 1;
    if ($a == 0) {           #allow
        @tabus = intersection(\@tabuser, \@userallow);
    } elsif ($a == 1) {      #deny
        foreach my $name (@tabuser) {
            foreach my $valuser (@userdeny) {
                if ($name eq $valuser) {
                    $stat = 0; last;
                } else {
                    $stat = 1;
                }
            }
            push @tabus, @tabus if $stat;
        }
    }
    @tabus
}

##recherche
sub user_allow {
    my ($allow, $testval, $user, $call) = @_;
    foreach my $string (@$user) {
        if ($string eq $testval) {
            if ($allow == -1 && $call == 0) {
                $allow = 0; last;
            } elsif ($allow == 0 && $call == 1) {
                $allow = 2; last;
            } elsif ($allow == -1 && $call == 1) {
                $allow = 1; last;
            }
        }
    }
    return $allow;
}


# Research users having the permission to use CRONTAB
sub get_logname {
    my ($call, $testuser) = @_;
    my $allow = -1;
    my (@filelist, @userlist);
    $Clspool->clear;
    if ($> == 0) {
        my $spool_file =  "/etc/passwd";
        #we must compare /etc/passwd file and /etc/cron.allow
        @tabdec = split /\s/, cat_($spool_file);
        foreach (@tabdec) {
            @tabtemp = split /:/;
            push @tabuser, $tabtemp[0] if $tabtemp[2] == 0 || $tabtemp[2] > 500 && $tabtemp[2] < 65500;
        }
    } else {
        @tabuser = (split /x/, getpwuid($>))[0];
    }
    if (-e $file_allow) {
        @userallow = split /\n/, cat_($file_allow);
        foreach (user_logname_compare(0)) {
            
            # In user mode we can't access to the /var/spool/cron/<name> path
            push @filelist, $_ if $> == 0 && -e "/var/spool/cron/$_";
            push @userlist, $_ unless $call;
        }
        $allow = user_allow($allow, $testuser, \@userlist,0);
        spool_file_cron(\@filelist, $allow, $testuser);
    } else {
        if (-e $file_deny) {
            @userdeny = split /\n/, cat_($file_deny);
            foreach (user_logname_compare(1)) {
                # In user mode we can't access to the /var/spool/cron/<name> path
                push @filelist, $_ if $> == 0 && -e "/var/spool/cron/$_";
                push @userlist, $_ unless $call;
            }
            $allow = user_allow($allow, $testuser, \@userlist,0);
            spool_file_cron(\@filelist, $allow, $testuser);
        } else {
            
            # In user mode we can't access to the /var/spool/cron/<name> path
            push @filelist, grep { -e "/var/spool/cron/$_" } @tabuser if $> == 0;
            $allow = user_allow($allow, $testuser, \@tabuser,0);
            spool_file_cron(\@filelist, $allow, $testuser);
            
        }
    }
    ##AT##
    my @tablog;
    
    if (-e $atfile_allow) {
        @userallow = split /\n/, cat_($atfile_allow);
        unless ($call) {
            @tablog = user_logname_compare(0);
            $allow = user_allow($allow, $testuser, \@tablog,1);
            spool_table_refresh($edtlevel, $allow);
        }
    } else {
        if (-e $atfile_deny) {
            @userdeny = split /\n/, cat_($atfile_deny);
            unless ($call) {
                @tablog = user_logname_compare(1);
                $allow = user_allow($allow, $testuser, \@tablog,1);
                spool_table_refresh($edtlevel, $allow);
            }
        } else {
            unless ($call) {
                $allow = user_allow($allow, $testuser, \@tabuser,1);
                spool_table_refresh($edtlevel, $allow);
            }
        }
    }
    return $allow;
}

sub init_add_task {
    my ($allow, $mode) = @_;
    if ($allow == 0) {
        $mode->set_active(1);
        gtkset_sensitive($mode, 0);
    } elsif ($allow == 1) {
        $mode->set_active(0);
        gtkset_sensitive($mode, 0);
    }
}

sub cron_format_getback_elements {
    $req = "$_[1] $_[0] $_[2] $_[3] $_[4] $_[6] ";
    $req .= " >$_[5]" unless $_[5] eq "";
}

sub at_format_getback_elements {
    if ($atboolmail == 1) {
        $atboolmail = 0;
        $_[0]->insert(undef, $_[0]->style->black,undef, "at ");
        $_[6] ||= 'a';
        $atoptlv = "-q $_[6]";
        $_[0]->insert(undef, $_[0]->style->black,undef, "-q $_[6] ");
        $_[0]->insert(undef, $_[0]->style->black,undef, "$_[1]:");
        unless ($_[3] eq "") {
            $_[0]->insert(undef, $_[0]->style->black,undef, "$_[2] ");
            $_[0]->insert(undef, $_[0]->style->black,undef, $_[3]);
        }
    }
    $_[0]->insert(undef, $_[0]->style->black,undef, "\n$_[5]");
    $_[0]->insert(undef, $_[0]->style->black,undef, " >$_[4]") unless $_[4] eq "";
}

sub add_command_button {
  my ($text, $w1, $w2, $w3, $w4, $i1, $i2, $w7, $w8, $w9, $w10, $w11) = @_;
    my ($x, $y);                # BUG: never set
    # my $mode =
    ($row, $column) = $Clspool->get_selection_info($x, $y);
    $Clspool->unselect_row($row, $column);
    gtkset_sensitive($w1, 0);
    gtkset_sensitive($w2, 0);

    if (!$w4) {         #################    AT     ################
        ##Time Frame: We are going to get H and M
        my $Hvalueat = $i1->get_value_as_int;
        my $Mvalueat = $i2->get_value_as_int;
        ##Calendar
        my $Date = calendar_changed($w7);
        ##Command Frame: We are going to get SENDTO, Ouput file and Command
        my $lvletter = $w8->get_text;
        my $Ofilevalueat = $w9->get_text;
        my $Cmdvalueat = $w10->get_text;

        if ($Cmdvalueat ne "") {
            unless ($ataddcount == 1) {
                $text->backward_delete($text->get_length);
                $ataddcount = 1;
            }
            $text->set_editable(1);
            at_format_getback_elements($text, $Hvalueat, $Mvalueat, $Date, $Ofilevalueat, $Cmdvalueat, $lvletter);
            gtkset_sensitive($w3, 1);
        } else {
            warnmsg(N("You must define a command first!"));
        }
    } else {     #################      CRON      ####################
        ##Time Frame: We are going to get H and M
        my $Hvaluecr = $i1->get_text;
        my $Mvaluecr = $i2->get_text;
        ##Date Frame: We are going to get Month, Day of Week and Day of Month
        my $Mthvaluecr = $w7->get_text;
        my $DoWvaluecr = $w8->get_text;
        my $DoMvaluecr = $w9->get_text;
        ##Command Frame: We are going to get SENDTO, Ouput file and Command
        #    my $Sendtovalue = $w10->get_text;
        my $Ofilevaluecr = $w10->get_text;
        my $Cmdvaluecr = $w11->get_text;

        ##Creation of the request
        #Format: MI H JM MH JW <cmd> <output>
      SWITCH: {
            $Hvaluecr = '*', if $Hvaluecr eq "";
            $Mvaluecr = '*', if $Mvaluecr eq "";
            $Mthvaluecr = '*', if $Mthvaluecr eq "";
            $DoWvaluecr = '*', if $DoWvaluecr eq "";
            $DoMvaluecr = '*', if $DoMvaluecr eq "";
        }

        #Set an entry test for this following  instruction
        if ($Cmdvaluecr ne "") {
            unless ($addcount == 1) {
                $text->backward_delete($text->get_length);
                $addcount = 1;
            }
            $text->editable(1);
            cron_format_getback_elements($Hvaluecr, $Mvaluecr, $Mthvaluecr, $DoWvaluecr, $DoMvaluecr, $Ofilevaluecr, $Cmdvaluecr);
            gtkset_sensitive($w3, 1);
        } else {
            warnmsg(N("You must define a command first!"));
        }
    }
}

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