#!/usr/bin/perl -w
use strict;
use Gtk2 '-init';

##################################################
# README
#
# Enlightenment_Remote Made Easy
#
# Changelog
# *version 0.3 
#    - add display option, and don't start 
#      erme is e17 is not found (andreas volz suggestion)
#      all command line option for erme are send to enligntenment_remote 
#    - add PRETEND constant - don't execute any changes if VERBOSE is set
#      it will show what command should be executed
#    - add lang option
#    - add modules tab
#    - add default-bg in desktop tabs
#    - add size_groups to align the widgets (i did it ;)
#    - add more action values (now it should hang less often)
#    - fix new key bug (thanks to chema olles)
#    - modules tab can now display status for modules loaded with absolute path
#      it can not modify them yet (thanks to dienekes)
#    - mouse param is now a free combo box
#    - WIN modifier is added for keys and mouse (thanks Ferdinand Hübner)
#    - comma is with double "m" (thanks Shamsuddin Baldick)
#    - added WIN modifier for signal and wheel
#
# *version 0.2 (28.09.2005)
#    - add signal and wheel binding
#    - write a general binding code - i'm still not happy with it
#    - fix a delete bug - no repetition
#    - fix other bugs
#    - add font-cache and image-cache
#-------------------------------------------------------------------
# KNOWN PROBLEMS
# -ANY_MOD don't function very well. it's from enlightenmet_remote.
# -signal binding works only if ANY_MOD is ON
# - there is a problem if you modify a binding and then delete it. erme will not
#   delete the binding but update it. if you want to delete it use a simple delete.
#   this is my fault. i will fix it pretty soon
#-------------------------------------------------------------------
# This code is release under a public domain licence
#
# You will need GTK2::Perl to run this script.
# 
# 
# Enlightenment_remote change often and you must keep
#   this script updated.
#
# The combo box values may change frequently so please
# update them
#
# The code from Mouse and key bindings is a mess
# The code from Options and Winlist is designed to be
#   modified very easy. So you should modify it
#   very easy.
#
# KEY and ACTION field are STRICT, please add your option into 
# @key_vals  or @action_vals arrays. YOU can not add new values
# from the program
#
# When you press NEW button a new row will be create at the bottom
# of the list. you must scrool to see it. It will be initialized with
# a -> exec Eterm
#
# When you press DELETE button the row will be unmaped. i was to lasy to
# unpack and remap the whole table.
#
# Options and Winlist tabs are very simple. If you want to modify the code
# just use one of the following functions add_bool, add_string, 
# add_string_free, add_num. 
#
#######################
# values for COMBO BOXE
### this value must be updated at each change of e17
my @context_vals =('ANY','ZONE','BORDER','CONTAINER','POPUP');
my @key_vals = ('a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z',
      'Insert','Tab','Menu','Delete','Meta','Home','End',
      'Prior','Next','Pause','Print',
      'bracketright','bracketleft','apostrophe','backslash','semicolon',
      'comma','period','slash','space',
      'F1','F2','F3','F4','F5','F6','F7','F8','F9','F10','F11','F12',
      'Left','Up','Down','Right');

my @action_vals = ('desktop_linear_flip_to',
       'desktop_linear_flip_by',
       'desk_flip_by',
       'window_menu','window_close','window_kill',
       'window_raise','window_lower', 
	'window_sticky_toggle','window_iconic_toggle',
	'window_maximized_toggle',
	'window_shaded_toggle','window_shaded',
	'window_drag_icon',
	'window_move','window_resize',
       'edit_mode_toggle','edit_mode',
       'menu_show',
       'winlist',
	'exit','restart',
       'exec',);

my @mouse_button_vals = ('1','2','3');

my @par_vals = ('','main','favorites','clients');


my @signal_source_vals = (
			  'title','icon','close','maximize','minimize',
			  'resize_tl','resize_t','resize_tr',
			  'resize_r','resize_l',
			  'resize_b','resize_bl','resize_br',
			  'resize_*',
			  );

my @wheel_z_vals = ('1','-1');
my @wheel_direction_vals = ('1','0');
# the end
##########################################

##########################################
# GLOBAL CONSTANTS
use constant TRUE  => 1;
use constant FALSE => 0;

use constant LOAD  => 1;
use constant ADD => 0;

use constant DEV => 0;
use constant DEBUG => 0;
use constant VERBOSE => 1;
use constant PRETEND => 0;

# ADD THIS in the order they are 
# added to notepad
use constant TAB_KEYS => 0;
use constant TAB_MOUSE => 1;
use constant TAB_SIGNAL => 2;
use constant TAB_WHEEL => 3;
use constant TAB_OPTIONS => 4;
use constant TAB_WINLIST => 5;
use constant TAB_DESKTOP => 6;
use constant TAB_MODULES => 7;

##########################################
# GLOBAL VARIABLES

  #for keys tab
my @context;
my @key;
my @mod_alt;
my @mod_ctrl;
my @mod_shift;
my @mod_win;
my @any;
my @action;
my @par;
my @delete;

  #for keys tab initial field values
my @init_key;
my @init_mod;
my @init_action;
my @init_par;

#################################
#for mouse tab
my @mouse_context;
my @mouse_button;
my @mouse_mod_alt;
my @mouse_mod_ctrl;
my @mouse_mod_shift;
my @mouse_mod_win;
my @mouse_mod_any;
my @mouse_any;
my @mouse_action;
my @mouse_params;
my @mouse_delete;

my @mouse_init_context;
my @mouse_init_button;
my @mouse_init_mod;
my @mouse_init_action;
my @mouse_init_params;
my @mouse_init_any;
my @mouse_deleted;

my $mouse_sg_context = Gtk2::SizeGroup->new ('horizontal');
my $mouse_sg_button = Gtk2::SizeGroup->new ('horizontal');
my $mouse_sg_mod = Gtk2::SizeGroup->new ('horizontal');
my $mouse_sg_any = Gtk2::SizeGroup->new ('horizontal');
my $mouse_sg_action = Gtk2::SizeGroup->new ('horizontal');
my $mouse_sg_params = Gtk2::SizeGroup->new ('horizontal');
my @mouse_sgs =(
		$mouse_sg_context,
		$mouse_sg_button,
		$mouse_sg_mod,
		$mouse_sg_any,
		$mouse_sg_action,
		$mouse_sg_params,
		);


############################
# for signal tab
my @signal_context;
my @signal_signal;
my @signal_source;
my @signal_any;
my @signal_action;
my @signal_params;
my @signal_mod_alt;
my @signal_mod_ctrl;
my @signal_mod_shift;
my @signal_mod_win;

my @signal_del_button;
my @signal_deleted;
my @signal_hbox;

my @signal_init_mod;
my @signal_init_context;
my @signal_init_signal;
my @signal_init_source;
my @signal_init_any;
my @signal_init_action;
my @signal_init_params;

my $signal_i=0;
my $signal_vbox;

my $signal_sg_context = Gtk2::SizeGroup->new ('horizontal');
my $signal_sg_signal = Gtk2::SizeGroup->new ('horizontal');
my $signal_sg_source = Gtk2::SizeGroup->new ('horizontal');
my $signal_sg_mod = Gtk2::SizeGroup->new ('horizontal');
my $signal_sg_any = Gtk2::SizeGroup->new ('horizontal');
my $signal_sg_action = Gtk2::SizeGroup->new ('horizontal');
my $signal_sg_params = Gtk2::SizeGroup->new ('horizontal');
my @signal_sgs =(
		$signal_sg_context,
		$signal_sg_signal,
		$signal_sg_source,
		$signal_sg_mod,
		$signal_sg_any,
		$signal_sg_action,
		$signal_sg_params,
		);

############################
# for signal tab
my @wheel_context;
my @wheel_direction;
my @wheel_z;
my @wheel_any;
my @wheel_action;
my @wheel_params;
my @wheel_mod_alt;
my @wheel_mod_ctrl;
my @wheel_mod_shift;
my @wheel_mod_win;

my @wheel_del_button;
my @wheel_deleted;
my @wheel_hbox;

my @wheel_init_mod;
my @wheel_init_context;
my @wheel_init_direction;
my @wheel_init_z;
my @wheel_init_any;
my @wheel_init_action;
my @wheel_init_params;

my $wheel_i=0;
my $wheel_vbox;

my $wheel_sg_context = Gtk2::SizeGroup->new ('horizontal');
my $wheel_sg_direction = Gtk2::SizeGroup->new ('horizontal');
my $wheel_sg_z = Gtk2::SizeGroup->new ('horizontal');
my $wheel_sg_mod = Gtk2::SizeGroup->new ('horizontal');
my $wheel_sg_any = Gtk2::SizeGroup->new ('horizontal');
my $wheel_sg_action = Gtk2::SizeGroup->new ('horizontal');
my $wheel_sg_params = Gtk2::SizeGroup->new ('horizontal');
my @wheel_sgs =(
		$wheel_sg_context,
		$wheel_sg_direction,
		$wheel_sg_z,
		$wheel_sg_mod,
		$wheel_sg_any,
		$wheel_sg_action,
		$wheel_sg_params,
		);
##################################
#general layout
my $hbox;
my $vbox_key;
my $vbox_mouse;
my $notebook;

my $init_nr = 0;
my $i = 0;
my $m_i = 0;
my @deleted_keys;


#containers for fields
my $vboxk_context;
my $vboxk_key;
my $vboxk_mod_alt;
my $vboxk_mod_ctrl;
my $vboxk_mod_shift;
my $vboxk_mod_win;
my $vboxk_any;
my $vboxk_action;
my $vboxk_par;
my $vboxk_delete;

my %value_bool;
my %value_num;
my %value_string;
my %value_string_free;

my %widget_bool;
my %widget_num;
my %widget_string;
my %widget_string_free;

####################################
# for modules tab
my @module_names;

my $module_size_group_name = Gtk2::SizeGroup->new ('horizontal');;
my $module_size_group_load = Gtk2::SizeGroup->new ('horizontal');;
my $module_size_group_enable = Gtk2::SizeGroup->new ('horizontal');;
my @module_size_groups = ($module_size_group_name,$module_size_group_load,$module_size_group_enable);

my %module_load;
my %module_enable;
my %module_load_val;
my %module_enable_val;


#######################################
# get command line options
# and
# check for e17 on that display

my $er_cmd = "enlightenment_remote @ARGV";
open(KBL, "$er_cmd|");
while (<KBL>){
    if (/ERROR:/){
	print $_;
	print <KBL>;
	exit;
    }
}
print ("E17 was found on the specified display.\n") if VERBOSE;

#######################################3
# WINDOW
my $window = Gtk2::Window->new;
$window->set_title ('enlightenment_remote made easy');
$window->resize (750, 400);
   
# signal 1, attached to the main window, when it is destroyed, clicked close 
# button, <alt-f4>, etc., quit the main loop
$window->signal_connect (destroy => sub { Gtk2->main_quit; });

# END OF WINDOW DEF
#===================================

#create and pack the containers
my $vboxmain = Gtk2::VBox->new(FALSE, 5);
my $temp_cont;
$notebook=Gtk2::Notebook->new();

$window->add($vboxmain);
#add top buttons
if (VERBOSE) {print "Adding control buttons\n"}
add_buttons($vboxmain); 


#add notebook
$vboxmain->pack_start($notebook,TRUE,TRUE, 0);

#add keys
if (VERBOSE) {print "Adding keys binding\n"}
$temp_cont = Gtk2::HBox->new(TRUE, 5); 
$notebook->append_page ($temp_cont, "Keys");
add_keys($temp_cont) if !DEV;

#add mouse
if (VERBOSE) {print "Adding mouse binding\n"}
$temp_cont = Gtk2::HBox->new(TRUE, 5); 
$notebook->append_page ($temp_cont, "Mouse");
add_mouse($temp_cont) if !DEV;

#add signal bindings
if (VERBOSE) {print "Adding signal binding\n"}
$temp_cont = Gtk2::HBox->new(TRUE, 5); 
$notebook->append_page ($temp_cont, "Signal");
add_signal($temp_cont) if !DEV;

#add wheel bindigns
if (VERBOSE) {print "Adding wheel binding\n"}
$temp_cont = Gtk2::HBox->new(TRUE, 5); 
$notebook->append_page ($temp_cont, "Wheel");
add_wheel($temp_cont) if !DEV;

#add options
if (VERBOSE) {print "Adding general options\n"}
$temp_cont = Gtk2::HBox->new(TRUE, 5); 
$notebook->append_page ($temp_cont, "Options");
add_options($temp_cont) if !DEV;

#add winlist
if (VERBOSE) {print "Adding winlist options\n"}
$temp_cont = Gtk2::HBox->new(TRUE, 5); 
$notebook->append_page ($temp_cont, "Winlist");
add_winlist($temp_cont) if !DEV;

#add desktop
if (VERBOSE) {print "Adding desktop options\n"}
$temp_cont = Gtk2::HBox->new(TRUE, 5); 
$notebook->append_page ($temp_cont, "Desktops");
add_desktop($temp_cont) if !DEV;

#add modules
if (VERBOSE) {print "Adding modules options\n"}
$temp_cont = Gtk2::HBox->new(TRUE, 5); 
$notebook->append_page ($temp_cont, "Modules");
add_modules($temp_cont) if !DEV;


#start the fire
$window->show_all;
Gtk2->main;




################################
# TOP BUTToNS
sub add_buttons
{
          my $hboxb = Gtk2::HBox->new(FALSE, 5);    
          $_[0]->pack_start($hboxb, FALSE, TRUE, 0);
          
          my $button_new = Gtk2::Button->new ('New');
          $button_new->signal_connect (clicked => \&action_new);
      
          my $button_ok = Gtk2::Button->new ('OK');
          $button_ok->signal_connect (clicked => \&action_ok);
      
          my $button_cancel = Gtk2::Button->new ('Cancel');
          $button_cancel->signal_connect (clicked => sub { Gtk2->main_quit; });
      
          my $button_apply = Gtk2::Button->new ('Apply');
          $button_apply->signal_connect (clicked => \&action_apply);
      
          $hboxb->pack_start($button_new, FALSE, TRUE, 0);
          $hboxb->pack_start($button_apply, FALSE, TRUE, 0);
          $hboxb->pack_start($button_ok, FALSE, TRUE, 0);
          $hboxb->pack_start($button_cancel, FALSE, TRUE, 0);
      
}

####################################################################
# KEYS tab
#####################################################################

sub add_keys
  {
      #
      my $pane_box = Gtk2::VBox->new(FALSE,0);
      $_[0]->pack_start($pane_box, TRUE, TRUE, 0);


      my $hboxk = Gtk2::HBox->new(FALSE, 5);
      $pane_box->pack_start($hboxk, FALSE, FALSE,0);
  
      my $table_header;
      
      #create table header
      
      #CONTEXT IS OUT
      #$table_header = Gtk2::Label->new('Context');
      #$vboxk_context = Gtk2::VBox->new(FALSE, 5);
      #$vboxk_context->pack_start($table_header,FALSE,FALSE,5);
      #$hboxk->pack_start($vboxk_context,FALSE,FALSE,0);
      
      $table_header = Gtk2::Label->new('Key');
      $vboxk_key = Gtk2::VBox->new(FALSE, 5);
      $vboxk_key->pack_start($table_header,FALSE,FALSE,5);
      $hboxk->pack_start($vboxk_key,FALSE,FALSE,0);
        
      $table_header = Gtk2::Label->new('Alt');
      $vboxk_mod_alt = Gtk2::VBox->new(FALSE, 5);
      $vboxk_mod_alt->pack_start($table_header,FALSE,FALSE,5);
      $hboxk->pack_start($vboxk_mod_alt,FALSE,FALSE,0);
      
      $table_header = Gtk2::Label->new('Ctrl');
      $vboxk_mod_ctrl = Gtk2::VBox->new(FALSE, 5);
      $vboxk_mod_ctrl->pack_start($table_header,FALSE,FALSE,5);
      $hboxk->pack_start($vboxk_mod_ctrl,FALSE,FALSE,0);
      
      $table_header = Gtk2::Label->new('Shift');
      $vboxk_mod_shift = Gtk2::VBox->new(FALSE, 5);
      $vboxk_mod_shift->pack_start($table_header,FALSE,FALSE,5);
      $hboxk->pack_start($vboxk_mod_shift,FALSE,FALSE,0);

      $table_header = Gtk2::Label->new('Win');
      $vboxk_mod_win = Gtk2::VBox->new(FALSE, 5);
      $vboxk_mod_win->pack_start($table_header,FALSE,FALSE,5);
      $hboxk->pack_start($vboxk_mod_win,FALSE,FALSE,0);
      
      #ANY IS OUT
      #$table_header = Gtk2::Label->new('Any');
      #$vboxk_any = Gtk2::VBox->new(FALSE, 5);
      #$vboxk_any->pack_start($table_header,FALSE,FALSE,5);
      #$hboxk->pack_start($vboxk_any,FALSE,FALSE,0);
      
      $table_header = Gtk2::Label->new('Action');
      $vboxk_action = Gtk2::VBox->new(FALSE, 5);
      $vboxk_action->pack_start($table_header,FALSE,FALSE,5);
      $hboxk->pack_start($vboxk_action,FALSE,FALSE,0);
      
      $table_header = Gtk2::Label->new('Parameters');
      $vboxk_par = Gtk2::VBox->new(FALSE, 5);
      $vboxk_par->pack_start($table_header,FALSE,FALSE,5);
      $hboxk->pack_start($vboxk_par,FALSE,FALSE,0);
      
      $table_header = Gtk2::Label->new('');
      $vboxk_delete = Gtk2::VBox->new(FALSE, 5);
      $vboxk_delete->pack_start($table_header,FALSE,FALSE,5);
      $hboxk->pack_start($vboxk_delete,FALSE,FALSE,0);
      
      #end of table header

      #define scrooled windows
      my $sw = Gtk2::ScrolledWindow->new(undef,undef);
      $pane_box->pack_start($sw,TRUE,TRUE, 0);
      
          
      #define layout
      $vbox_key = Gtk2::VBox->new(FALSE, 5);
      $sw->add_with_viewport ($vbox_key);
      

      $hboxk = Gtk2::HBox->new(FALSE, 5);
      $vbox_key->pack_start($hboxk, FALSE, FALSE,0);
      
        my $key_i;
        my $key_field;
        my $mod_alt_i;
        my $mod_ctrl_i;
        my $mod_field;
        my $any_i;
        my $action_i;
        my $action_field;
        my $par_i;
        my $par_field;
        my $delete_i;
      
        #now parse the output of e_remote -bind-key-list and create the widgets
        open(KBL, "$er_cmd -binding-key-list|");
        while (<KBL>){
                if (/REPLY: BINDING CONTEXT=(.*) KEY="(.*)" MODIFIERS=(.*) ANY_MOD=(.*) ACTION="(.*)" PARAMS="(.*)".*/){
                    if (DEBUG) {print "context=$1 key=$2 mod=$3 any=$4 action=$5 par=$6\n";}
                    
                    $mod_field=$3;
                    $key_field=$2;
                    $action_field=$5;
                    $par_field=$6;
                    
                    #instance variables - created temporarly and then added to the array - are overwrited 
                    # in the next iteration
                    if ($i > 0) {
                            $hbox = Gtk2::HBox->new(FALSE, 5);
                            $vbox_key->pack_start($hbox, TRUE, TRUE, 0);
                        }
                    
                    #CONTEXT IS OUT
                    #add_field_context();
                    add_field_key(LOAD,$key_field);
                    add_field_mod_alt(LOAD,$mod_field);
                    add_field_mod_ctrl(LOAD,$mod_field);
                    add_field_mod_shift(LOAD,$mod_field);
                    add_field_mod_win(LOAD,$mod_field);
                    add_field_action(LOAD,$action_field);
                    add_field_par(LOAD,$par_field);
                    add_key_field_delete();
                    
                    
                    #====ANY
                    #$any_i = Gtk2::Label->new('0');
                    #$vboxk_any->pack_start($any_i, FALSE, FALSE, 4);
                     
                    
                    #increment i
                    $i++;
                    
                        }
              }
       
        $init_nr = $i;
      }
#################################################################3
# FIELDS

sub add_field_key
{
    my $key_field = $_[1];
    if ($_[0] == LOAD) 
    {
	push(@init_key,$key_field);
    }else{
	push(@init_key,"a");
    }
    
    #====KeY
    my $key_i = Gtk2::Combo->new ();
    @key = (@key, $key_i);
    
    $key[$i]->set_popdown_strings(@key_vals);
    $key[$i]->set('enable-arrow-keys',TRUE);
    $key[$i]->set('value-in-list',TRUE);
    $key[$i]->set('allow-empty' ,FALSE);
    
    $key[$i]->entry->set_text ($key_field);
    
    if ($i == 0)
    {
	$vboxk_key->pack_start($key[$i], FALSE, FALSE, 0);
    }else{
	$hbox->pack_start($key[$i], FALSE, FALSE, 0);
    }
}

sub add_field_mod_alt
{
    my $mod_field = $_[1];
    if ($_[0] == LOAD) 
    {
	push(@init_mod,$mod_field);
    }else{
	push(@init_mod,"");
    }
       
    #====MOD ALT
    my $mod_alt_i = Gtk2::CheckButton->new();
    if ( $mod_field =~ /.*ALT.*/) {$mod_alt_i->set_active (TRUE);}
      
    @mod_alt = (@mod_alt, $mod_alt_i);
      
      
    if ($i == 0)
    {
	$vboxk_mod_alt->pack_start($mod_alt[$i],FALSE,FALSE,0);
    }else{
	$hbox->pack_start($mod_alt[$i], FALSE, FALSE, 0);
    }
    
}

sub add_field_mod_ctrl
  {
          my $mod_field = $_[1];
          #==== MOD CTRL
          my $mod_ctrl_i = Gtk2::CheckButton->new();
          if ( $mod_field =~ /.*CTRL.*/) {$mod_ctrl_i->set_active (TRUE);}
          
          @mod_ctrl = (@mod_ctrl, $mod_ctrl_i);
      
      
          if ($i == 0)
            {
                $vboxk_mod_ctrl->pack_start($mod_ctrl[$i],FALSE,FALSE,0);
                    }else{
                        $hbox->pack_start($mod_ctrl[$i], FALSE, FALSE, 0);
                            }
      
      }

sub add_field_mod_shift
  {
          my $mod_field = $_[1];
          #==== MOD CTRL
          my $mod_shift_i = Gtk2::CheckButton->new();
          if ( $mod_field =~ /.*SHIFT.*/) {$mod_shift_i->set_active (TRUE);}
          
          @mod_shift = (@mod_shift, $mod_shift_i);
      
          if ($i == 0)
            {
                $vboxk_mod_shift->pack_start($mod_shift[$i],FALSE,FALSE,0);
                    }else{
                        $hbox->pack_start($mod_shift[$i], FALSE, FALSE, 0);
                            }
      
      }

sub add_field_mod_win
  {
          my $mod_field = $_[1];
          #==== MOD win
          my $mod_win_i = Gtk2::CheckButton->new();
          if ( $mod_field =~ /.*WIN.*/) {$mod_win_i->set_active (TRUE);}
          
          push (@mod_win, $mod_win_i);
      
          if ($i == 0)
            {
                $vboxk_mod_win->pack_start($mod_win[$i],FALSE,FALSE,0);
	    }else{
		$hbox->pack_start($mod_win[$i], FALSE, FALSE, 0);
	    }
	  
      }


sub add_field_action
  {
          my $field_action = $_[1];
          if ($_[0] == LOAD) 
            { 
                push(@init_action,$field_action);
                    }else{
                        push(@init_action,"exec");
                            }
          
          #====ACTION
          my $action_i = Gtk2::Combo->new ();
          @action = (@action, $action_i);
      
       
          $action[$i]->set_popdown_strings(@action_vals);
          $action[$i]->set('enable-arrow-keys',TRUE);
          $action[$i]->set('value-in-list',TRUE);
          $action[$i]->set('allow-empty' ,FALSE);
      
          $action[$i]->entry->set_text ($field_action);
      
          if ($i == 0)
            {
                $vboxk_action->pack_start($action[$i], FALSE, FALSE, 0);
                    }else{
                        $hbox->pack_start($action[$i], FALSE, FALSE, 0);
                            }
      
      }

sub add_field_par
  {
          my $field_par = $_[1];
          if ($_[0] == LOAD) 
            {
                push(@init_par,$field_par);
                    }else{
                        push(@init_par,"xterm");
                            }
      
          #====PAR
          my $par_i = Gtk2::Combo->new ();
          @par = (@par, $par_i);
       
          $par[$i]->set_popdown_strings(@par_vals);
          $par[$i]->set('enable-arrow-keys',TRUE);
          #$action[$i]->set('value-in-list',TRUE);
          #$action[$i]->set('allow-empty' ,FALSE);
          
          $par[$i]->entry->set_text ($field_par);
      
          if ($i == 0)
            {
                       $vboxk_par->pack_start($par[$i], FALSE, FALSE, 0);
                    }else{
                        $hbox->pack_start($par[$i], FALSE, FALSE, 0);
                            }
      
      }

sub add_key_field_delete
{      
    #====DETELE button
    my $delete_i = Gtk2::Button->new ('Delete');
    $delete_i->signal_connect (clicked => \&action_delete_key, $i);
    
    @delete = (@delete,$delete_i);
    
    if ($i == 0)
    {
	$vboxk_delete->pack_start($delete_i, FALSE, FALSE, 1);
    }else{
	$hbox->pack_start($delete_i, FALSE, FALSE, 0);
    }
    
}

  #APPLY KEYS
sub action_apply_keys
{
          my @keys_probably_updated;
          my @keys_updated;
          my $iter;
      
          #FIRST DELETE ALL KEY FROM @deleted_keys
	  
          foreach $iter (@deleted_keys){
	      my $cmd_del = "$er_cmd -binding-key-del ANY $init_key[$iter] \"$init_mod[$iter]\" 0 $init_action[$iter] \"$init_par[$iter]\"";
                  print "$cmd_del \n" if VERBOSE;
                  system ($cmd_del) if !PRETEND;
		  
	  }
	  @deleted_keys = ();

          for (my $j=0; $j<$i; $j++){
                  if (!member(@deleted_keys,$j))  {push (@keys_probably_updated,$j);}
                  }
          if (DEBUG) {print "Keys probably updated @keys_probably_updated \n";}
      
          foreach $iter (@keys_probably_updated){
              my $has_changed = FALSE;
              $has_changed=FALSE;
              my $new_mod = "";
              my $new_key = $key[$iter]->entry->get_text();
              my $new_action = $action[$iter]->entry->get_text();
              my $new_par = $par[$iter]->entry->get_text();
              
              #if ($iter < $init_nr) {
                      if ($init_key[$iter] ne $new_key) {$has_changed=TRUE;}
                      if ($init_action[$iter] ne $new_action) {$has_changed=TRUE;}
                      if ($init_par[$iter] ne $new_par) {$has_changed=TRUE;}
                  
                      if ($mod_shift[$iter]->get_active()) {$new_mod=$new_mod."|SHIFT"};
                      if ($mod_ctrl[$iter]->get_active()) {$new_mod=$new_mod."|CTRL"};
                      if ($mod_alt[$iter]->get_active()) {$new_mod=$new_mod."|ALT"};
                      if ($mod_win[$iter]->get_active()) {$new_mod=$new_mod."|WIN"};

                      if ($new_mod eq "") {$new_mod="NONE";}
                      if (substr($new_mod,0,1) eq '|') {$new_mod=substr($new_mod,1);}
                  
                      if ($init_mod[$iter] ne $new_mod) {$has_changed=TRUE;}
                  #}else {$has_changed = TRUE;}
              
              if ($has_changed == TRUE) {
                      
                      my $cmd_add = "$er_cmd -binding-key-add ANY $new_key \"$new_mod\" 0 \"$new_action\" \"$new_par\"";
                      my $cmd_del = "$er_cmd -binding-key-del ANY $init_key[$iter] \"$init_mod[$iter]\" 0 \"$init_action[$iter]\" \"$init_par[$iter]\"";
                      
                      system ($cmd_del) if !PRETEND;
                      print "$iter: $cmd_del \n" if VERBOSE;
                      system ($cmd_add) if !PRETEND;
                      print "$iter: $cmd_add \n" if VERBOSE;
                      
                      #after we have added a key we update the init fields
                      $init_key[$iter]=$new_key;
                      $init_mod[$iter]=$new_mod;
                      $init_action[$iter]=$new_action;
                      $init_par[$iter]=$new_par;
                      
                  }
	  }
}

sub action_delete_key
{
    
    my $id = $_[1];
    my $widget = $_[0];
    push (@deleted_keys,$id);
    
    
    #hide the row TODO
    $delete[$id]->unmap;
    
    #CONTEXT IS OUT
    #$context[$id]->unmap;
    $key[$id]->unmap;
    $mod_alt[$id]->unmap;
    $mod_ctrl[$id]->unmap;
    $mod_shift[$id]->unmap;
    $mod_win[$id]->unmap;
    $action[$id]->unmap;
    $par[$id]->unmap;
    
    #print "s-a apasat $_[1] in $_[0] nr $i\n";
    $window->show_all;
      
}

sub action_new_keys
{
    
    if ($i > 0) {
	$hbox = Gtk2::HBox->new(FALSE, 5);
	$vbox_key->pack_start($hbox, TRUE, TRUE, 0);
    }
    
    add_field_key(ADD,'a');
    add_field_mod_alt(ADD,'NONE');
    add_field_mod_ctrl(ADD,'NONE');
    add_field_mod_shift(ADD,'NONE');
    add_field_mod_win(ADD,'NONE');
    add_field_action(ADD,'exec');
    add_field_par(ADD,'xterm');
    add_key_field_delete();
    $i++;
    
    $window->show_all;
}

########################################################################
# MOUSE TAB
#########################################################################
sub add_mouse
{
#binding-mouse-list /add del
# CONTEXT BUTTON MODIFIERS ACTION
      #
    my $hboxk;
    my $pane_box = Gtk2::VBox->new(FALSE,0);
      $_[0]->pack_start($pane_box, TRUE, TRUE, 0);

      #define scrooled windows
      my $sw = Gtk2::ScrolledWindow->new(undef,undef);
      $pane_box->pack_start($sw,TRUE,TRUE, 0);
      
      #define layout
      $vbox_mouse = Gtk2::VBox->new(FALSE, 5);
      $sw->add_with_viewport ($vbox_mouse);      

      $hboxk = Gtk2::HBox->new(FALSE, 5);
      $vbox_mouse->pack_start($hboxk, FALSE, FALSE,0);

      add_header(
		 $hboxk,
		 "Context,Button,Alt Ctrl Shift Win,Any_Mod,Action,Params",
		 \@mouse_sgs,
		 );

      
      my $context_field;
      my $button_field;
      my $mod_field;
      my $action_field;
      my $par_field;
    my $field_any;

      #now parse the output of e_remote -bind-key-list and create the widgets
      open(KBL, "$er_cmd -binding-mouse-list|");
      while (<KBL>){
	  if (/REPLY: BINDING CONTEXT=(.*) BUTTON=(.*) MODIFIERS=(.*) ANY_MOD=(.*) ACTION="(.*)" PARAMS="(.*)".*/){
	      if (DEBUG) {print "context=$1 button=$2 mod=$3 any=$4 action=$5 par=$6\n";}
              
	      $context_field=$1;
	      $mod_field=$3;
	      $field_any=$4;
	      $button_field=$2;
	      $action_field=$5;
	      $par_field=$6;
                    
	      #instance variables - created temporarly and then added to the array - are overwrited 
	      # in the next iteration
	     
	      $hbox = Gtk2::HBox->new(FALSE, 5);
	      $vbox_mouse->pack_start($hbox, FALSE, FALSE, 0);
	      
	      #ADD fields
	      add_field_mouse_context($context_field);
	      add_field_mouse_button($button_field);
	      add_field_mouse_mod_alt($mod_field);
	      add_field_mouse_mod_ctrl($mod_field);
	      add_field_mouse_mod_shift($mod_field);
	      add_field_mouse_mod_win($mod_field);
	      add_field_mouse_any($field_any);
	      add_field_mouse_action($action_field);
	      add_field_mouse_par($par_field);
	      add_field_mouse_delete();
                    
	      #increment i
	      $m_i++;
	  }
      }
       
      $init_nr = $i;
  }

 #############################################################
 #MOUSE - field - context
sub add_field_mouse_context
{
    my $field_content = $_[0];
    push(@mouse_init_context,$field_content);
    
    
    #====context
    my $field = Gtk2::Combo->new ();
    $field->set_popdown_strings(@context_vals);
    $field->set('enable-arrow-keys',TRUE);
    $field->set('value-in-list',TRUE);
    $field->set('allow-empty' ,FALSE);
    $field->entry->set_text ($field_content);
    $hbox->pack_start($field, FALSE, FALSE, 0);

    $mouse_sg_context->add_widget($field);
    push (@mouse_context, $field);    
}

sub add_field_mouse_button
{
    my $field_content = $_[0];
    push(@mouse_init_button,$field_content);
        
    #====context
    my $field = Gtk2::Combo->new ();
    $field->set_popdown_strings(@mouse_button_vals);
    $field->set('enable-arrow-keys',TRUE);
    $field->set('value-in-list',TRUE);
    $field->set('allow-empty' ,FALSE);
    $field->entry->set_text ($field_content);
    $hbox->pack_start($field, FALSE, FALSE, 0);

    $mouse_sg_button->add_widget($field);
    push (@mouse_button, $field);    

}

sub add_field_mouse_mod_alt
{
    my $field_content = $_[0];
    push(@mouse_init_mod,$field_content);
           
    #====MOD ALT
    my $field = Gtk2::CheckButton->new();
    if ( $field_content =~ /.*ALT.*/) {$field->set_active (TRUE);}
      
    $hbox->pack_start($field, FALSE, FALSE, 0);
    push (@mouse_mod_alt, $field);
}

sub add_field_mouse_mod_ctrl
{
    my $field_content = $_[0];
    #====MOD CTRL
    my $field = Gtk2::CheckButton->new();
    if ( $field_content =~ /.*CTRL.*/) {$field->set_active (TRUE);}
      
    $hbox->pack_start($field, FALSE, FALSE, 0);
    push (@mouse_mod_ctrl, $field);

}

sub add_field_mouse_mod_shift
{
    my $field_content = $_[0];
    #====MOD SHIFT
    my $field = Gtk2::CheckButton->new();
    if ( $field_content =~ /.*SHIFT.*/) {$field->set_active (TRUE);}
      
    $hbox->pack_start($field, FALSE, FALSE, 0);
    push (@mouse_mod_shift, $field);

}

sub add_field_mouse_mod_win
{
    my $field_content = $_[0];
    #====MOD SHIFT
    my $field = Gtk2::CheckButton->new();
    if ( $field_content =~ /.*WIN.*/) {$field->set_active (TRUE);}
      
    $hbox->pack_start($field, FALSE, FALSE, 0);
    push (@mouse_mod_win, $field);

}


sub add_field_mouse_any
{
    my $field_content = $_[0];
    push(@mouse_init_any,$field_content);
           
    #====MOD ALT
    my $field = Gtk2::CheckButton->new();
    if ( $field_content == 1) {$field->set_active (TRUE);}
      
    $hbox->pack_start($field, FALSE, FALSE, 0);

    $mouse_sg_any->add_widget($field);
    push (@mouse_any, $field);
}


sub add_field_mouse_action
{
    my $field_content = $_[0];
    push(@mouse_init_action,$field_content);
    
    #====context
    my $field = Gtk2::Combo->new ();
    $field->set_popdown_strings(@action_vals);
    $field->set('enable-arrow-keys',TRUE);
    $field->set('value-in-list',TRUE);
    $field->set('allow-empty' ,FALSE);
    $field->entry->set_text ($field_content);
    $hbox->pack_start($field, FALSE, FALSE, 0);

    $mouse_sg_action->add_widget($field);
    push (@mouse_action, $field);    

}

sub add_field_mouse_par
{
    my $field_content = $_[0];
    push(@mouse_init_params,$field_content);
    
    #====context
    my $field = Gtk2::Combo->new ();
    $field->set_popdown_strings(@par_vals);
    $field->set('enable-arrow-keys',TRUE);
    #$field->set('value-in-list',TRUE);
    $field->set('allow-empty' ,FALSE);
    $field->entry->set_text ($field_content);
    $hbox->pack_start($field, FALSE, FALSE, 0);

    $mouse_sg_params->add_widget($field);
    push (@mouse_params, $field);    

}

sub add_field_mouse_delete
{
    #====DETELE button
    my $field = Gtk2::Button->new ('Delete');
    $field->signal_connect (clicked => \&action_delete_mouse, $m_i);
    
    $hbox->pack_start($field, FALSE, FALSE, 0);
    push (@mouse_delete,$field);      
    
}

sub action_delete_mouse
{
    my $id = $_[1];
    my $widget = $_[0];
    push (@mouse_deleted,$id);
        
    
    #hide the row TODO
    $mouse_delete[$id]->unmap;
       
        
    $mouse_context[$id]->unmap;
    $mouse_button[$id]->unmap;
    $mouse_mod_alt[$id]->unmap;
    $mouse_mod_ctrl[$id]->unmap;
    $mouse_mod_shift[$id]->unmap;
    $mouse_action[$id]->unmap;
    $mouse_params[$id]->unmap;
         
    $window->show_all;
 
}

sub action_new_button
{
    $hbox = Gtk2::HBox->new(FALSE, 5);
    $vbox_mouse->pack_start($hbox, FALSE, FALSE, 0);
    
    #ADD fields
    add_field_mouse_context("ZONE");
    add_field_mouse_button("1");
    add_field_mouse_mod_alt("NONE");
    add_field_mouse_mod_ctrl("");
    add_field_mouse_mod_shift("");
    add_field_mouse_mod_win("");
    add_field_mouse_any(0);
    add_field_mouse_action("menu_show");
    add_field_mouse_par("clients");
    add_field_mouse_delete();
                    
    #increment i
    $m_i++;
    $window->show_all;

}

sub action_apply_mouse
{
    my @fields_probably_updated;
    my @fields_updated;
    my $iter;
      
    #FIRST DELETE ALL KEY FROM @deleted_keys
    
    foreach $iter (@mouse_deleted){
	my $cmd_del = "$er_cmd -binding-mouse-del $mouse_init_context[$iter] $mouse_init_button[$iter] \"$mouse_init_mod[$iter]\" $mouse_init_any[$iter] $mouse_init_action[$iter] \"$mouse_init_params[$iter]\"";
	print "$cmd_del \n";
	system ($cmd_del) if !PRETEND;
	
    }
    @mouse_deleted = ();
    for (my $j=0; $j<$m_i; $j++){
	if (!member(@mouse_deleted,$j))  {push (@fields_probably_updated,$j);}
    }
    if (DEBUG) {print "Mouse probably updated @fields_probably_updated \n";}
    
    foreach $iter (@fields_probably_updated){
	my $has_changed = FALSE;
	$has_changed=FALSE;
	my $new_any=0;
	my $new_mod = "";
	my $new_context = $mouse_context[$iter]->entry->get_text();
	my $new_button = $mouse_button[$iter]->entry->get_text();
	my $new_action = $mouse_action[$iter]->entry->get_text();
	my $new_par = $mouse_params[$iter]->entry->get_text();
	
	#if ($iter < $init_nr) {
	if ($mouse_init_button[$iter] ne $new_button) {$has_changed=TRUE;}
	if ($mouse_init_action[$iter] ne $new_action) {$has_changed=TRUE;}
	if ($mouse_init_params[$iter] ne $new_par) {$has_changed=TRUE;}
	if ($mouse_init_context[$iter] ne $new_context) {$has_changed=TRUE;}
	
	if ($mouse_mod_shift[$iter]->get_active()) {$new_mod=$new_mod."|SHIFT"};
	if ($mouse_mod_ctrl[$iter]->get_active()) {$new_mod=$new_mod."|CTRL"};
	if ($mouse_mod_alt[$iter]->get_active()) {$new_mod=$new_mod."|ALT"};
	if ($mouse_mod_win[$iter]->get_active()) {$new_mod=$new_mod."|WIN"};
	
	if ($new_mod eq "") {$new_mod="NONE";}
	if (substr($new_mod,0,1) eq '|') {$new_mod=substr($new_mod,1);}
	
	if ($mouse_init_mod[$iter] ne $new_mod) {$has_changed=TRUE;}
	
	if ($mouse_any[$iter]->get_active()) {$new_any=1}else{$new_any=0;};
	if ($mouse_init_any[$iter] != $new_any) {$has_changed = TRUE;}

	if ($has_changed == TRUE) {
	    
	    my $cmd_add = "$er_cmd -binding-mouse-add $new_context $new_button \"$new_mod\" $new_any $new_action \"$new_par\"";
	    my $cmd_del = "$er_cmd -binding-mouse-del $mouse_init_context[$iter] $mouse_init_button[$iter] \"$mouse_init_mod[$iter]\" $mouse_init_any[$iter] $mouse_init_action[$iter] \"$mouse_init_params[$iter]\"";
	    
	    system ($cmd_del) if !PRETEND;
	    print "$iter: $cmd_del \n" if VERBOSE;
	    system ($cmd_add) if !PRETEND;
	    print "$iter: $cmd_add \n" if VERBOSE;
	    
	    #after we have added a key we update the init fields
	    $mouse_init_context[$iter]=$new_context;
	    $mouse_init_button[$iter]=$new_button;
	    $mouse_init_mod[$iter]=$new_mod;
	    $mouse_init_any[$iter]=$new_any;
	    $mouse_init_action[$iter]=$new_action;
	    $mouse_init_params[$iter]=$new_par;
                      
	}
    }
    
}
###########################################################################
# SIGNAL TAB
############################################################################
sub add_signal
{
      my $pane_box = Gtk2::VBox->new(FALSE,0);
      $_[0]->pack_start($pane_box, TRUE, TRUE, 0);
      my $hbox = Gtk2::HBox->new(FALSE, 5);
      $pane_box->pack_start($hbox, FALSE, FALSE,0);
  
    
      #define scrooled windows
      my $sw = Gtk2::ScrolledWindow->new(undef,undef);
      $pane_box->pack_start($sw,TRUE,TRUE, 0);
  
      #define layout
      $signal_vbox = Gtk2::VBox->new(FALSE, 5);
      $sw->add_with_viewport ($signal_vbox);      

      $hbox = Gtk2::HBox->new(FALSE, 5);
      $signal_vbox->pack_start($hbox, FALSE, FALSE,0);

      add_header(
		 $hbox,
		 "Context,Signal,Source,Alt Ctrl Shift Win,Any_Mod,Action,Params",
		 \@signal_sgs,
		 );

      signal_add_rows($signal_vbox);

}

sub signal_add_rows
{
    my $vbox=$_[0];
    my $context_field;
    my $signal_field;
    my $source_field;
    my $mod_field;
    my $any_field;
    my $action_field;
    my $par_field;
    my $hbox;

    $signal_i=0;
    #now parse the output of e_remote -bind-key-list and create the widgets
    open(KBL, "$er_cmd -binding-signal-list|");
    while (<KBL>){
	if (/REPLY: BINDING CONTEXT=(.*) SIGNAL=(.*) SOURCE=(.*) MODIFIERS=(.*) ANY_MOD=(.*) ACTION="(.*)" PARAMS="(.*)".*/){
	    if (DEBUG) {print "context=$1 signal=$2 source=$3 mod=$4 any=$5 action=$6 par=$7\n";}
	    
	    $context_field=$1;
	    $mod_field=$4;
	    $signal_field=$2;
	    $source_field=$3;
	    $any_field=$5;
	    $action_field=$6;
	    $par_field=$7;
	    
	    signal_add_row(
			   $vbox,
			   $context_field,
			   $signal_field,
			   $source_field,
			   $mod_field,
			   $any_field,
			   $action_field,
			   $par_field
			   );

	}
    }
    
    
}

sub signal_add_row
{
    my $vbox = $_[0];
    my $context_field = $_[1];
    my $signal_field = $_[2];
    my $source_field =$_[3];
    my $mod_field = $_[4];
    my $any_field = $_[5];
    my $action_field = $_[6];
    my $par_field = $_[7];

    my $hbox = Gtk2::HBox->new(FALSE, 5);
    $vbox->pack_start($hbox, FALSE, FALSE, 0);
    push(@signal_hbox, $hbox);


    #ADD fields
    #context
    add_field_string(
		     $hbox,
		     $context_field,
		     \@context_vals,
		     \@signal_context,
		     \@signal_init_context,
		     $signal_sg_context,
		     );
    
    #signal
    add_field_string_free(
			  $hbox,
			  $signal_field,
			  \@signal_signal,
			  \@signal_init_signal,
			  $signal_sg_signal,
			  );
    #source
    add_field_string(
		     $hbox,
		     $source_field,
		     \@signal_source_vals,
		     \@signal_source,
		     \@signal_init_source,
		     $signal_sg_source,
		     );
    #modifiers
    add_field_mod(
		  $hbox,
		  $mod_field,
		  \@signal_init_mod,
		  \@signal_mod_alt,
		  \@signal_mod_ctrl,
		  \@signal_mod_shift,
		  \@signal_mod_win,
		  $signal_sg_mod,
		  
		  );
    add_field_bool(
		   $hbox,
		   $any_field,
		   \@signal_any,
		   \@signal_init_any,
		   $signal_sg_any,
		   );
    
    #actions
    add_field_string(
		     $hbox,
		     $action_field,
		     \@action_vals,
		     \@signal_action,
		     \@signal_init_action,
		     $signal_sg_action,
		     );
    add_field_string_free(
			  $hbox,
			  $par_field,
			  \@signal_params,
			  \@signal_init_params,
			  $signal_sg_params,
			  );
    add_field_delete($hbox,$signal_i,TAB_SIGNAL);
	    
    #increment i
    $signal_i++;
}

sub signal_action_new
{
    signal_add_row(
		   $signal_vbox,
		   "BORDER",
		   "mouse,down,1",
		   "title",
		   "NONE",
		   "1",
		   "window_menu",
		   ""
		   );
    $signal_hbox[$signal_i-1]->show_all;
}

sub signal_action_delete
{
    my $id = $_[1];
    my $widget = $_[0];
    push (@signal_deleted,$id);
    $signal_hbox[$id]->unmap;
}

sub signal_action_apply
{
    my @fields_probably_updated;
    my @fields_updated;
    my $iter;
      
    #FIRST DELETE ALL KEY FROM @deleted_keys
    
    foreach $iter (@signal_deleted){
	my $cmd_del = "$er_cmd -binding-signal-del \"$signal_init_context[$iter]\" \"$signal_init_signal[$iter]\" \"$signal_init_source[$iter]\" \"$signal_init_mod[$iter]\" 1 \"$signal_init_action[$iter]\" \"$signal_init_params[$iter]\"";
	print "$cmd_del \n" if VERBOSE;
	system ($cmd_del) if !PRETEND;
	
    }
    @signal_deleted = ();
       
    for (my $j=0; $j<$signal_i; $j++){
	if (!member(@signal_deleted,$j))  {push (@fields_probably_updated,$j);}
    }
    if (DEBUG) {print "Signal probably updated @fields_probably_updated \n";}
    
    foreach $iter (@fields_probably_updated){
	my $has_changed = FALSE;
	$has_changed=FALSE;

	my $new_context = $signal_context[$iter]->entry->get_text();
	if ($signal_init_context[$iter] ne $new_context) {$has_changed=TRUE;}

	my $new_signal = $signal_signal[$iter]->get_text();
	if ($signal_init_signal[$iter] ne $new_signal) {$has_changed=TRUE;}

	my $new_source = $signal_source[$iter]->entry->get_text();
	if ($signal_init_source[$iter] ne $new_source) {$has_changed=TRUE;}

	my $new_action = $signal_action[$iter]->entry->get_text();
	if ($signal_init_action[$iter] ne $new_action) {$has_changed=TRUE;}

	my $new_params = $signal_params[$iter]->get_text();
	if ($signal_init_params[$iter] ne $new_params) {$has_changed=TRUE;}
       
	my $new_any = 0;
	if ($signal_any[$iter]->get_active()) {$new_any=1};
	if ($signal_init_any[$iter] != $new_any) {$has_changed=TRUE;}

	my $new_mod = "";
	if ($signal_mod_shift[$iter]->get_active()) {$new_mod=$new_mod."|SHIFT"};
	if ($signal_mod_ctrl[$iter]->get_active()) {$new_mod=$new_mod."|CTRL"};
	if ($signal_mod_alt[$iter]->get_active()) {$new_mod=$new_mod."|ALT"};
	if ($signal_mod_win[$iter]->get_active()) {$new_mod=$new_mod."|WIN"};
	
	if ($new_mod eq "") {$new_mod="NONE";}
	if (substr($new_mod,0,1) eq '|') {$new_mod=substr($new_mod,1);}
	
	if ($signal_init_mod[$iter] ne $new_mod) {$has_changed=TRUE;}
	
	
	if ($has_changed == TRUE) {
	    
	    my $cmd_add = "$er_cmd -binding-signal-add \"$new_context\" \"$new_signal\" \"$new_source\" \"$new_mod\" \"$new_any\" \"$new_action\" \"$new_params\"";
	    my $cmd_del = "$er_cmd -binding-signal-del \"$signal_init_context[$iter]\" \"$signal_init_signal[$iter]\" \"$signal_init_source[$iter]\" \"$signal_init_mod[$iter]\" \"$signal_init_any[$iter]\" \"$signal_init_action[$iter]\" \"$signal_init_params[$iter]\"";
	    
	    system ($cmd_del) if !PRETEND;
	    print "$iter: $cmd_del \n" if VERBOSE;
	    system ($cmd_add) if !PRETEND;
	    print "$iter: $cmd_add \n" if VERBOSE;
	    
	    # we update the init fields
	    $signal_init_context[$iter]=$new_context;
	    $signal_init_signal[$iter]=$new_signal;
	    $signal_init_source[$iter]=$new_source;
	    $signal_init_mod[$iter]=$new_mod;
	    $signal_init_any[$iter]=$new_any;
	    $signal_init_action[$iter]=$new_action;
	    $signal_init_params[$iter]=$new_params;
                      
	}
    }
    

}


###########################################################################
# WHELL TAB
############################################################################
sub add_wheel
{
      my $pane_box = Gtk2::VBox->new(FALSE,0);
      $_[0]->pack_start($pane_box, TRUE, TRUE, 0);
      my $hbox = Gtk2::HBox->new(FALSE, 5);
      $pane_box->pack_start($hbox, FALSE, FALSE,0);
  
    
      #define scrooled windows
      my $sw = Gtk2::ScrolledWindow->new(undef,undef);
      $pane_box->pack_start($sw,TRUE,TRUE, 0);
  
      #define layout
      $wheel_vbox = Gtk2::VBox->new(FALSE, 5);
      $sw->add_with_viewport ($wheel_vbox);      

      $hbox = Gtk2::HBox->new(FALSE, 5);
      $wheel_vbox->pack_start($hbox, FALSE, FALSE,0);

    add_header($hbox,
		 "Context,Direction,Z,Alt Ctrl Shift Win,Any_Mod,Action,Params",
		 \@wheel_sgs);
  

      wheel_add_rows($wheel_vbox);

}

sub wheel_add_rows
{
    my $vbox=$_[0];
    my $context_field;
    my $direction_field;
    my $z_field;
    my $mod_field;
    my $any_field;
    my $action_field;
    my $par_field;
    my $hbox;

    $wheel_i=0;
    #now parse the output of e_remote and create the widgets
    open(KBL, "$er_cmd -binding-wheel-list|");
    while (<KBL>){
	if (/REPLY: BINDING CONTEXT=(.*) DIRECTION=(.*) Z=(.*) MODIFIERS=(.*) ANY_MOD=(.*) ACTION="(.*)" PARAMS="(.*)".*/){
	    if (DEBUG) {print "context=$1 DIRECTION=$2 Z=$3 mod=$4 any=$5 action=$6 par=$7\n";}
	    
	    $context_field=$1;
	    $mod_field=$4;
	    $direction_field=$2;
	    $z_field=$3;
	    $any_field=$5;
	    $action_field=$6;
	    $par_field=$7;
	    
	    wheel_add_row(
			   $vbox,
			   $context_field,
			   $direction_field,
			   $z_field,
			   $mod_field,
			   $any_field,
			   $action_field,
			   $par_field
			   );

	}
    }
    
    
}

sub wheel_add_row
{
    my $vbox = $_[0];
    my $context_field = $_[1];
    my $direction_field = $_[2];
    my $z_field =$_[3];
    my $mod_field = $_[4];
    my $any_field = $_[5];
    my $action_field = $_[6];
    my $par_field = $_[7];

    my $hbox = Gtk2::HBox->new(FALSE, 5);
    $vbox->pack_start($hbox, FALSE, FALSE, 0);
    push(@wheel_hbox, $hbox);


    #ADD fields
    #context
    add_field_string(
		     $hbox,
		     $context_field,
		     \@context_vals,
		     \@wheel_context,
		     \@wheel_init_context,
		     $wheel_sg_context,
		     );
    
    #direction 0 1
    add_field_string(
		     $hbox,
		     $direction_field,
		     \@wheel_direction_vals,
		     \@wheel_direction,
		     \@wheel_init_direction,
		     $wheel_sg_direction,
		     );
    #Z 1 -1
    add_field_string(
		     $hbox,
		     $z_field,
		     \@wheel_z_vals,
		     \@wheel_z,
		     \@wheel_init_z,
		     $wheel_sg_z,
		     );
    #modifiers
    add_field_mod(
		  $hbox,
		  $mod_field,
		  \@wheel_init_mod,
		  \@wheel_mod_alt,
		  \@wheel_mod_ctrl,
		  \@wheel_mod_shift,
		  \@wheel_mod_win,
		  $wheel_sg_mod,
		  );
    #ANY_MOD
    add_field_bool(
		   $hbox,
		   $any_field,
		   \@wheel_any,
		   \@wheel_init_any,
		   $wheel_sg_any,
		   );
    
    #actions
    add_field_string(
		     $hbox,
		     $action_field,
		     \@action_vals,
		     \@wheel_action,
		     \@wheel_init_action,
		     $wheel_sg_action,
		     );
    #params
    add_field_string_free(
			  $hbox,
			  $par_field,
			  \@wheel_params,
			  \@wheel_init_params,
			  $wheel_sg_params,
			  );
    add_field_delete($hbox,$wheel_i,TAB_WHEEL);
	    
    #increment i
    $wheel_i++;
}

sub wheel_action_new
{
    wheel_add_row(
		   $wheel_vbox,
		   "CONTAINER",
		   "0",
		   "-1",
		   "NONE",
		   "1",
		   "desk_linear_flip_by",
		   "-1"
		   );
    $wheel_hbox[$wheel_i-1]->show_all;
}

sub wheel_action_delete
{
    my $id = $_[1];
    my $widget = $_[0];
    push (@wheel_deleted,$id);
    $wheel_hbox[$id]->unmap;
}

sub wheel_action_apply
{
    my @fields_probably_updated;
    my @fields_updated;
    my $iter;
      
    #FIRST DELETE ALL KEY FROM @deleted_keys
    
    foreach $iter (@wheel_deleted){
	my $cmd_del = "$er_cmd -binding-wheel-del \"$wheel_init_context[$iter]\" \"$wheel_init_direction[$iter]\" \"$wheel_init_z[$iter]\" \"$wheel_init_mod[$iter]\" \"$wheel_init_any[$iter]\" \"$wheel_init_action[$iter]\" \"$wheel_init_params[$iter]\"";
	print "$cmd_del \n" if VERBOSE;
	system ($cmd_del) if !PRETEND;
	
    }
    @wheel_deleted = ();
       
    for (my $j=0; $j<$wheel_i; $j++){
	if (!member(@wheel_deleted,$j))  {push (@fields_probably_updated,$j);}
    }
    if (DEBUG) {print "Wheel probably updated @fields_probably_updated \n";}
    
    foreach $iter (@fields_probably_updated){
	my $has_changed = FALSE;
	$has_changed=FALSE;

	my $new_context = $wheel_context[$iter]->entry->get_text();
	if ($wheel_init_context[$iter] ne $new_context) {$has_changed=TRUE;}

	my $new_direction = $wheel_direction[$iter]->entry->get_text();
	if ($wheel_init_direction[$iter] ne $new_direction) {$has_changed=TRUE;}

	my $new_z = $wheel_z[$iter]->entry->get_text();
	if ($wheel_init_z[$iter] ne $new_z) {$has_changed=TRUE;}

	my $new_action = $wheel_action[$iter]->entry->get_text();
	if ($wheel_init_action[$iter] ne $new_action) {$has_changed=TRUE;}

	my $new_params = $wheel_params[$iter]->get_text();
	if ($wheel_init_params[$iter] ne $new_params) {$has_changed=TRUE;}
       
	my $new_any = 0;
	if ($wheel_any[$iter]->get_active()) {$new_any=1};
	if ($wheel_init_any[$iter] != $new_any) {$has_changed=TRUE;}

	my $new_mod = "";
	if ($wheel_mod_shift[$iter]->get_active()) {$new_mod=$new_mod."|SHIFT"};
	if ($wheel_mod_ctrl[$iter]->get_active()) {$new_mod=$new_mod."|CTRL"};
	if ($wheel_mod_alt[$iter]->get_active()) {$new_mod=$new_mod."|ALT"};
	if ($wheel_mod_win[$iter]->get_active()) {$new_mod=$new_mod."|WIN"};
	
	if ($new_mod eq "") {$new_mod="NONE";}
	if (substr($new_mod,0,1) eq '|') {$new_mod=substr($new_mod,1);}
	
	if ($wheel_init_mod[$iter] ne $new_mod) {$has_changed=TRUE;}
	
	
	if ($has_changed == TRUE) {
	    
	    my $cmd_add = "$er_cmd -binding-wheel-add \"$new_context\" \"$new_direction\" \"$new_z\" \"$new_mod\" \"$new_any\" \"$new_action\" \"$new_params\"";
	    my $cmd_del = "$er_cmd -binding-wheel-del \"$wheel_init_context[$iter]\" \"$wheel_init_direction[$iter]\" \"$wheel_init_z[$iter]\" \"$wheel_init_mod[$iter]\" \"$wheel_init_any[$iter]\" \"$wheel_init_action[$iter]\" \"$wheel_init_params[$iter]\"";
	    
	    system ($cmd_del) if !PRETEND;
	    print "$iter: $cmd_del \n" if VERBOSE;
	    system ($cmd_add) if !PRETEND;
	    print "$iter: $cmd_add \n" if VERBOSE;
	    
	    # we update the init fields
	    $wheel_init_context[$iter]=$new_context;
	    $wheel_init_direction[$iter]=$new_direction;
	    $wheel_init_z[$iter]=$new_z;
	    $wheel_init_mod[$iter]=$new_mod;
	    $wheel_init_any[$iter]=$new_any;
	    $wheel_init_action[$iter]=$new_action;
	    $wheel_init_params[$iter]=$new_params;
                      
	}
    }
    

}

###########################################################################
# GENERAL BINDINGS FUNCTIONS
############################################################################
sub add_binding_header
{
    my $hboxk = $_[0];
    my @header_rows = split(/,/,$_[1]);
    my $row;
    my $table_header;
    my $vbox_temp;
    
    foreach $row (@header_rows){
      #print ("$row \n");
      #create table header
      $table_header = Gtk2::Label->new("$row");
      $vbox_temp = Gtk2::VBox->new(FALSE, 0);
      $vbox_temp->pack_start($table_header,FALSE,FALSE,5);
      $hboxk->pack_start($vbox_temp,FALSE,FALSE,0);
      
  }
    
    #end of table header
}

sub add_field_mod
{
    my $hbox = $_[0];
    my $field_content = $_[1];
    my $init_mod = $_[2];
    my $mod_alt = $_[3];
    my $mod_ctrl = $_[4];
    my $mod_shift = $_[5];
    my $mod_win = $_[6];
    my $sg = $_[7];
    my ($field_alt, $field_ctrl, $field_shift, $field_win);
    my $my_hbox = Gtk2::HBox->new(FALSE,0);
   
    #====MOD ALT
    $field_alt = Gtk2::CheckButton->new();
    if ( $field_content =~ /.*ALT.*/) {$field_alt->set_active (TRUE);} 
    $my_hbox->pack_start($field_alt, FALSE, FALSE, 0);
    
    #====MOD CTRL
    $field_ctrl = Gtk2::CheckButton->new();
    if ( $field_content =~ /.*CTRL.*/) {$field_ctrl->set_active (TRUE);}  
    $my_hbox->pack_start($field_ctrl, FALSE, FALSE, 0);
  
    #====MOD SHIFT
    $field_shift = Gtk2::CheckButton->new();
    if ( $field_content =~ /.*SHIFT.*/) {$field_shift->set_active (TRUE);}
    $my_hbox->pack_start($field_shift, FALSE, FALSE, 0);

    #====MOD WIN
    $field_win = Gtk2::CheckButton->new();
    if ( $field_content =~ /.*WIN.*/) {$field_win->set_active (TRUE);}
    $my_hbox->pack_start($field_win, FALSE, FALSE, 0);

    $hbox->pack_start($my_hbox, FALSE, FALSE, 0);
    $sg->add_widget($my_hbox);

    push(@$init_mod,$field_content);
    push(@$mod_alt,$field_alt);
    push(@$mod_ctrl,$field_ctrl);
    push(@$mod_shift,$field_shift);
    push(@$mod_win,$field_win);
        
}

sub add_field_bool
{
    my $hbox = $_[0];
    my $field_content = $_[1];
    my $references = $_[2];     
    my $init_values=$_[3];
    my $sg=$_[4];
    my $field;
           
    $field = Gtk2::CheckButton->new();
    if ( $field_content == 1) {$field->set_active (TRUE);} 
    $hbox->pack_start($field, FALSE, FALSE, 0);
    $sg->add_widget($field);
    push(@$init_values,$field_content);
    push(@$references, $field);    

}

sub add_field_string
{
    my $hbox=$_[0];
    my $field_content = $_[1];
    my $vals=$_[2];
    my $init_values=$_[4];
    my $references = $_[3];     
    my $sg = $_[5];

    #====context
    my $field = Gtk2::Combo->new ();
    $field->set_popdown_strings(@$vals);
    $field->set('enable-arrow-keys',TRUE);
    $field->set('value-in-list',TRUE);
    $field->set('allow-empty' ,FALSE);
    $field->entry->set_text ($field_content);
    $hbox->pack_start($field, FALSE, FALSE, 0);
    $sg->add_widget($field);
    push(@$init_values,$field_content);
    push (@$references, $field);    
}

sub add_field_string_free
{
    my $hbox=$_[0];
    my $field_content = $_[1];
    my $init_values=$_[3];
    my $references = $_[2];     
    my $sg = $_[4];

    #====context
    my $field = Gtk2::Entry->new ();
    $field->set_text ($field_content);
    $hbox->pack_start($field, FALSE, FALSE, 0);
    $sg->add_widget($field);
    push(@$init_values,$field_content);
    push (@$references, $field);    

}

sub add_field_delete
{
    my $hbox = $_[0];
    my $i = $_[1];
    my $tab = $_[2];
    #====DETELE button
    my $field = Gtk2::Button->new ('Delete');

    if ($tab == TAB_SIGNAL){
	$field->signal_connect (clicked => \&signal_action_delete, $i);
	push (@signal_del_button,$field);      
    }elsif ($tab == TAB_WHEEL){
	$field->signal_connect (clicked => \&wheel_action_delete, $i);
	push (@wheel_del_button,$field);      
    }

    $hbox->pack_start($field, FALSE, FALSE, 0); 
}

              
###########################################################################
# OPTIONS TAB
############################################################################

sub add_options
{

    my $sw = Gtk2::ScrolledWindow->new(undef,undef);
    $_[0]->pack_start($sw,FALSE,TRUE, 0);
    my $vbox_options = Gtk2::VBox->new(FALSE, 0); 
    my $hbox_options; 
    $sw->add_with_viewport($vbox_options);
    my $pack;

    #create a new row
    $hbox_options = Gtk2::HBox->new(FALSE, 5);
    $vbox_options->pack_start($hbox_options, FALSE, FALSE, 0); 


    # FOCUS
    $pack = frame_new($hbox_options,"Focus");
    add_string($pack,"focus-policy","CLICK,MOUSE,SLOPPY");
    add_string($pack,"focus-setting","NONE,NEW_WINDOW,NEW_DIALOG,NEW_DIALOG_IF_OWNER_FOCUSED");
    add_bool($pack,"focus-last-focused-per-desktop");   
    add_bool($pack,"focus-revert-on-hide-or-close");

    #resist
    $pack = frame_new($hbox_options,"Resist");
    add_bool($pack,"use-resist");
    add_num($pack,"drag-resist");
    add_num($pack,"window-resist");
    add_num($pack,"gadget-resist");

    #create a new row
    $hbox_options = Gtk2::HBox->new(FALSE, 5);
    $vbox_options->pack_start($hbox_options, FALSE, FALSE, 0); 

    #MISC
    $pack = frame_new($hbox_options,"Misc");
    add_string($pack,"maximize-policy","FULLSCREEN,SMART,EXPAND,FILL");
    add_string($pack,"window-placement-policy","SMART,CURSOR");
    add_list($pack,"lang");
    add_bool($pack,"pass-click-on");
    add_num($pack,"cursor-size");
    add_num($pack,"framerate");



    #managed window 
    $pack = frame_new($hbox_options,"Managed window");
    add_bool($pack,"kill-if-close-not-possible");
    add_bool($pack,"kill-process");
    add_num($pack,"kill-timer-wait");
    add_bool($pack,"ping-clients");
    add_num($pack,"ping-clients-wait");

    #create a new row
    $hbox_options = Gtk2::HBox->new(FALSE, 5);
    $vbox_options->pack_start($hbox_options, FALSE, FALSE, 0); 

    # Border shade
    $pack = frame_new($hbox_options,"Border shade and raise");
    add_bool($pack,"border-shade-animate");
    add_string($pack,"border-shade-transition","0,1,2,3");
    add_num($pack,"border-shade-speed");
    add_bool($pack,"always-click-to-raise");
    add_bool($pack,"use-auto-raise");
    add_num($pack,"auto-raise-delay");

    #transition
    $pack = frame_new($hbox_options,"Transition");
    add_string_free($pack,"transition-start");
    add_string_free($pack,"transition-desk");
    add_string_free($pack,"transition-change");


    #create a new row
    $hbox_options = Gtk2::HBox->new(FALSE, 5);
    $vbox_options->pack_start($hbox_options, FALSE, FALSE, 0); 

    #CACHE
    $pack = frame_new($hbox_options,"Cache options");
    add_num($pack,"font-cache");
    add_num($pack,"image-cache");

    # EDGE
    $pack = frame_new($hbox_options,"Edge");
    add_bool($pack,"edge-flip");
    add_num($pack,"edge-flip-timeout");

    #create a new row
    $hbox_options = Gtk2::HBox->new(FALSE, 5);
    $vbox_options->pack_start($hbox_options, FALSE, FALSE, 0); 
   

    #Transient
    $pack = frame_new($hbox_options,"Transient");
    add_bool($pack,"transient-move");
    add_bool($pack,"transient-resize");
    add_bool($pack,"transient-raise");
    add_bool($pack,"transient-lower");
    add_bool($pack,"transient-layer");
    add_bool($pack,"transient-desktop");
    add_bool($pack,"transient-iconify");



    #WINDOWS
    $pack = frame_new($hbox_options,"Windows");
    add_bool($pack,"resize-info-follows");
    add_bool($pack,"move-info-follows");
    add_bool($pack,"modal-windows");

    # MENU
    $pack = frame_new($hbox_options,"Menu");
    add_num($pack,"menus-scroll-speed");
    add_num($pack,"menus-fast-move-threshold");
    add_num($pack,"menus-click-drag-timeout");
    add_num($pack,"menu-autoscroll-margin");   
    add_bool($pack,"menu-autoscroll-cursor-margin");


}

####################################################################
# WINLIST tab
#####################################################################
sub add_winlist
{
    my $sw = Gtk2::ScrolledWindow->new(undef,undef);
    $_[0]->pack_start($sw,TRUE,TRUE, 0);
    my $vbox_options = Gtk2::VBox->new(FALSE, 0); 
    my $hbox_options; 
    $sw->add_with_viewport($vbox_options);
    my $pack;
   
    #create a new row
    $hbox_options = Gtk2::HBox->new(FALSE, 5);
    $vbox_options->pack_start($hbox_options, FALSE, FALSE, 0); 
    # FOCUS
    $pack = frame_new($hbox_options,"Warp");
    add_bool($pack,"winlist-warp-while-selecting");
    add_bool($pack,"winlist-warp-at-end");
    add_num($pack,"winlist-warp-speed");

    # Misc
    $pack = frame_new($hbox_options,"Misc");
    add_bool($pack,"winlist-scroll-animate");
    add_num($pack,"winlist-scroll-speed");

    #create a new row
    $hbox_options = Gtk2::HBox->new(FALSE, 5);
    $vbox_options->pack_start($hbox_options, FALSE, FALSE, 0); 
    
    # LIST
    $pack = frame_new($hbox_options,"List");
    add_bool($pack,"winlist-list-show-iconified");
    add_bool($pack,"winlist-list-show-other-desk-windows");
    add_bool($pack,"winlist-list-show-other-screen-windows");
    add_bool($pack,"winlist-list-uncover-while-selecting");
    add_bool($pack,"winlist-list-jump-desk-while-selecting");

    # Position
    $pack = frame_new($hbox_options,"Position");
    add_num($pack,"winlist-pos-align-x");
    add_num($pack,"winlist-pos-align-y");
    add_num($pack,"winlist-pos-size-w");
    add_num($pack,"winlist-pos-size-h");
    add_num($pack,"winlist-pos-min-w");
    add_num($pack,"winlist-pos-min-h");
    add_num($pack,"winlist-pos-max-w");
    add_num($pack,"winlist-pos-max-h");
}

####################################################################
# DESKTOP tab
#####################################################################
sub add_desktop
{
    my $sw = Gtk2::ScrolledWindow->new(undef,undef);
    $_[0]->pack_start($sw,TRUE,TRUE, 0);
    my $vbox_options = Gtk2::VBox->new(FALSE, 0); 
    $sw->add_with_viewport($vbox_options);
    my $pack;

    # FOCUS
    $pack = frame_new($vbox_options,"Desktop numbers");
    add_string_free($pack,"desks");
    add_file_selection($pack,"default-bg");

#desktop-name-list
}

####################################################################
# MODULES tab
#####################################################################
sub add_modules
{
    my $sw = Gtk2::ScrolledWindow->new(undef,undef);
    $_[0]->pack_start($sw,TRUE,TRUE, 0);
    my $vbox_options = Gtk2::VBox->new(TRUE, 0); 
    $sw->add_with_viewport($vbox_options);
    my $pack;

    # FOCUS
    $pack = frame_new($vbox_options,"Available modules");

    add_header($pack,"Name,Loaded,Enabled",\@module_size_groups);
    module_add_rows($pack);
    module_set_values()
}

sub module_add_rows
{
  my $hbox=$_[0]; 
  my $cmd;
  my $hbox_temp;

  $cmd = "$er_cmd -dirs-list modules";
  open (ER,"$cmd |");
  while (<ER>){
      if (/REPLY: \"(.*)\"/){
	  my $dir = $1;
	  open (LS,"ls -1 $dir|");
	  while (<LS>){
	      chomp();
	      $hbox_temp = Gtk2::HBox->new(FALSE, 5);
	      module_add_row($hbox_temp,$_);
	      $hbox->pack_start($hbox_temp,FALSE,FALSE,0);
	  }
      }
  }
  
  
}

sub module_add_row
{
    my $hbox = $_[0];
    my $name = $_[1];
    my $load;
    my $enable;

    #====Label
    my $field = Gtk2::Label->new ($name);
    $hbox->pack_start($field, FALSE, FALSE, 0);
    $module_size_group_name->add_widget($field);

    $load = Gtk2::CheckButton->new();
    $hbox->pack_start($load, FALSE, FALSE, 0);
    $module_size_group_load->add_widget($load);

    $enable = Gtk2::CheckButton->new();
    $hbox->pack_start($enable, FALSE, FALSE, 0);
    $module_size_group_enable->add_widget($enable);

    push (@module_names,$name);
    $module_load{$name}=$load;
    $module_load_val{$name}=0;
    $module_enable{$name}=$enable;
    $module_enable_val{$name}=0;
}

sub module_set_values
{
    my $cmd;
    my $name;
    my $enable;
    $cmd = "$er_cmd -module-list";
    open(ER,"$cmd |");
    while (<ER>){
	if (/REPLY: \"(.*)\" ENABLED (.)/){
	    $name = $1;
	    $enable = $2;
	    if ($name =~ /.*\/([a-zA-Z]*)\/[a-zA-Z0-9\-]*\/module\.so/)
		{$name = $1;}
	    $module_load{$name}->set_active(TRUE);
	    $module_load_val{$name}=1;

	    $module_enable{$name}->set_active(TRUE) if $enable; 
	    $module_enable_val{$name}=1 if $enable;
	    
	}
    }
}

sub module_action_apply
{
    my $name;
    my $cmd;
    foreach (@module_names){
	$name = $_;
	if ($module_load{$name}->get_active() xor $module_load_val{$name}){
	    print "$name has change\n" if DEBUG;
	    $module_load_val{$name} = $module_load{$name}->get_active()?1:0;
	  
	    #see if we need to load or unload the module
	    if ($module_load{$name}->get_active()){
		$cmd = "$er_cmd -module-load $name";
	    }else{
		$cmd = "$er_cmd -module-unload $name";
	    }
	    print "$cmd \n" if VERBOSE;
	    system($cmd) if !PRETEND;
	}
	#only if module is loaded  we enable it. else disable 
	if ($module_load{$name}->get_active()){
	    if ($module_enable{$name}->get_active() xor $module_enable_val{$name}){
		print "$name has enable change\n" if DEBUG;
		$module_enable_val{$name} = $module_enable{$name}->get_active()?1:0;
		#see if we need to load or unload the module
		if ($module_enable{$name}->get_active()){
		    $cmd = "$er_cmd -module-enable $name";
		}else{
		    $cmd = "$er_cmd -module-disable $name";
		}
		print "$cmd \n" if VERBOSE;
		system($cmd) if !PRETEND;
		
	    }
	}else{
	    $module_enable{$name}->set_active(FALSE);
	    $module_enable_val{$name}=0;
	}
    }
}
##################################################################3
# GENERAL APPLY
###################################################################
sub options_action_apply
{
  apply_bool();
  apply_num();
  apply_string();
  apply_string_free();
}

sub apply_bool
{
    my ($key,$value);
    my $cmd;
  
    while (($key,$value) = each(%value_bool)){
	if ($widget_bool{$key}->get_active() xor $value){
	    
	    if ($value){$value="0";}else{$value="1"};
	    $value_bool{"$key"}=$value;
	    $cmd = "$er_cmd -".$key."-set ".$value;
	    system ($cmd) if !PRETEND;
	    print "$cmd\n" if VERBOSE;
	}
    }     
    
}

sub apply_num
{
   my ($key,$prev_value);
   my $cmd;
   my $cur_value;
  
    while (($key,$prev_value) = each(%value_num)){
	$cur_value = $widget_num{$key}->get_text();
	if ( $cur_value ne $prev_value){
	    
	    $value_num{"$key"}=$cur_value;
	    
	    $cmd = "$er_cmd -".$key."-set ".$cur_value;
	    system ($cmd) if !PRETEND;
	    if (VERBOSE){print "$cmd\n";             }
	}
    }     
 
}

sub apply_string
{
    my ($key,$prev_value);
    my $cmd;
    my $cur_value;
    
    while (($key,$prev_value) = each(%value_string)){
	$cur_value = $widget_string{$key}->entry->get_text();
	if ( $cur_value ne $prev_value){
	    
	    $value_string{"$key"}=$cur_value;
	    
	    $cmd = "$er_cmd -".$key."-set \"".$cur_value."\"";
	    system ($cmd) if !PRETEND;
	    if (VERBOSE){ print "$cmd\n";}
	}
    }     
    
}

sub apply_string_free
{
   my ($key,$prev_value);
   my $cmd;
   my $cur_value;
   
   while (($key,$prev_value) = each(%value_string_free)){
       $cur_value = $widget_string_free{$key}->get_text();
       if ( $cur_value ne $prev_value){
	   
	   $value_string_free{"$key"}=$cur_value;
	   
	   $cmd = "$er_cmd -".$key."-set ".$cur_value;
	   system ($cmd) if !PRETEND;
	   if (VERBOSE){print "$cmd\n";             };
       }
   }     
   
   
}






########################################################
# AUX FUNCTION
#########################
# add a string option
sub add_bool
{
 my $pack = shift(@_);
 my $name = shift(@_);
 my $pack_hbox = Gtk2::HBox->new(FALSE, 1);
 $pack->pack_start($pack_hbox,TRUE,TRUE,0);

 my $label = Gtk2::Label->new($name);
 $pack_hbox->pack_start($label,FALSE,FALSE,0);

 my $value = get_value ($name);

 #handle exceptions
 if ($value =~ /[POLICY|KILL]=(.)/){$value=$1;}

 my $check_button = Gtk2::CheckButton->new();
 if ( $value eq "1") {$check_button->set_active (TRUE);}
 $pack_hbox->pack_start($check_button,FALSE,FALSE,0);

 $value_bool{"$name"}=$value;
 $widget_bool{"$name"}=$check_button;

}

########################333
# add a string option
sub add_string
{
 my $pack = shift(@_);
 my $name = shift(@_);
 my @options = split(/,/,$_[0]);
 my $pack_hbox = Gtk2::HBox->new(FALSE, 1);
 $pack->pack_start($pack_hbox,TRUE,TRUE,0);

 my $label = Gtk2::Label->new($name);
 $pack_hbox->pack_start($label,FALSE,FALSE,0);

 my $value = get_value ($name);
    
 #====context
 my $field = Gtk2::Combo->new ();
 $field->set_popdown_strings(@options);
 $field->set('enable-arrow-keys',TRUE);
 $field->set('value-in-list',TRUE);
 $field->set('allow-empty' ,FALSE);
 $field->entry->set_text ($value);
 $pack_hbox->pack_start($field, FALSE, FALSE, 0);


 $value_string{"$name"}=$value;
 $widget_string{"$name"}=$field;
}

########################
# add a free string option (no constrains in value) 
sub add_string_free
{
 my $pack = shift(@_);
 my $name = shift(@_);
 my $pack_hbox = Gtk2::HBox->new(FALSE, 1);
 $pack->pack_start($pack_hbox,TRUE,TRUE,0);

 my $label = Gtk2::Label->new($name);
 $pack_hbox->pack_start($label,FALSE,FALSE,0);

 my $value = get_value ($name);
 
 #clear quotes
 if ($value =~ /"(.*)"/){$value=$1;}
 
 my $field = Gtk2::Entry->new ();
 $field->set_text ($value);
 $pack_hbox->pack_start($field, FALSE, FALSE, 0);

 $value_string_free{"$name"}=$value;
 $widget_string_free{"$name"}=$field;
}


########################333
# add a numeric option
sub add_num
{
 my $pack = shift(@_);
 my $name = shift(@_);

 my $pack_hbox = Gtk2::HBox->new(FALSE, 1);
 $pack->pack_start($pack_hbox,TRUE,TRUE,0);

 my $label = Gtk2::Label->new($name);
 $pack_hbox->pack_start($label,FALSE,FALSE,0);
 
 my $value = get_value ($name);

 # handle exceptions
 if ($value =~ /[DELAY|THRESHOLD]=(.*)/){$value=$1;}

 my $field = Gtk2::Entry->new;
 $field->set_text($value);
 $pack_hbox->pack_start($field, FALSE, FALSE, 0);

 # set initial value
 $value_num{"$name"}=$value;
 $widget_num{"$name"}=$field;
}

############################
# add a listing option, it use string arch
sub add_list
{
 my $pack = shift(@_);
 my $name = shift(@_);
 my @options;
 my $cmd;
 my $pack_hbox = Gtk2::HBox->new(FALSE, 1);
 $pack->pack_start($pack_hbox,TRUE,TRUE,0);

 my $label = Gtk2::Label->new($name);
 $pack_hbox->pack_start($label,FALSE,FALSE,0);

 my $value = get_value ($name);
 
 #===get list options===
 $cmd = "$er_cmd -".$name."-list";
 open(ER,"$cmd |");
 while (<ER>){
     if (/REPLY: "(.*)"/) {
	 push (@options,$1);
     }
 }
   
 #====content
 my $field = Gtk2::Combo->new ();
 $field->set_popdown_strings(@options);
 $field->set('enable-arrow-keys',TRUE);
 $field->set('value-in-list',TRUE);
 $field->set('allow-empty' ,TRUE);
 $field->entry->set_text ($value);
 $pack_hbox->pack_start($field, FALSE, FALSE, 0);

 $value_string{"$name"}=$value;
 $widget_string{"$name"}=$field;
}


########################
# add a file selection option (no constrains in value)
# inferited from string_free 
sub add_file_selection
{
  my $pack = shift(@_);
  my $name = shift(@_);
  my $widget;
  my $pack_hbox = Gtk2::HBox->new(FALSE, 1);
  $pack->pack_start($pack_hbox,TRUE,TRUE,0);

  my $label = Gtk2::Label->new($name);
  $pack_hbox->pack_start($label,FALSE,FALSE,0);
  
  my $value = get_value ($name);
  
 #clear quotes
    
  my $field = Gtk2::Entry->new();
  $field->set_text ($value);
  $pack_hbox->pack_start($field, FALSE, FALSE, 0);
  
  $widget = Gtk2::Button->new_with_label("Chose file");
  $widget->signal_connect (clicked => \&action_chose_file,$name);
  $pack_hbox->pack_start($widget, FALSE, FALSE, 0);
  
  $value_string_free{"$name"}=$value;
  $widget_string_free{"$name"}=$field;
}

sub action_chose_file
{
    my $instance = shift(@_);
    my $name = shift(@_);
    my $fs = Gtk2::FileSelection->new("Chose file for $name");
    my @data = ($fs,$name);
    $fs->set_filename($value_string_free{"$name"});
    $fs->hide_fileop_buttons();
    $fs->set_select_multiple(FALSE);
    $fs->signal_connect("destroy",\&action_chose_file_close,$fs);
    $fs->cancel_button->signal_connect("clicked",\&action_chose_file_close,$fs);
    $fs->ok_button->signal_connect("clicked",\&action_chose_file_ok,\@data);
    $fs->show();
    

}

sub action_chose_file_close
{
    my $instance = shift(@_);
    $instance = shift(@_);
    $instance->destroy();
}

sub action_chose_file_ok
{
    my $instance = $_[0];
    my $data = $_[1];
    my $fs = @$data[0];
    my $name = @$data[1];
    my $fn=$fs->get_filename();

    
    print "$fn\n" if DEBUG;
    
    if (stat($fn)){
	print "file exist\n" if DEBUG;
	$widget_string_free{$name}->set_text($fn);
    }else{
	print "file not exist\n" if DEBUG;
    }
    $fs->destroy();
}
################################33
# GET option curren value
sub get_value
{
    my $value;
    open (ER,"$er_cmd -".$_[0]."-get|");
    my @buf = <ER>;
    $value = shift(@buf);
    $value = shift(@buf);
    chomp($value);
    if ($value=~/REPLY: (.*)/){$value = $1;}else{}

    #strip posible double quotes
    if ($value =~/\"(.*)\"/){$value = $1;}
    if (DEBUG){ print ("$_[0] $value\n");}
    return $value; 
}


#################
#CREATE A NEW frame
sub frame_new {
    my $frame_focus = Gtk2::Frame->new ($_[1]);
    $_[0]->pack_start($frame_focus, FALSE, FALSE, 0);
    my $frame_vbox = Gtk2::VBox->new(FALSE, 5);
    $frame_focus->add($frame_vbox);
    return $frame_vbox;
}
################################
# create a generic table header
sub add_header
{
    my $hboxk = $_[0];
    my @header_rows = split(/,/,$_[1]);
    my $size_group = $_[2];
    my $row;
    my $table_header;
    my $hbox_temp;
    my $i=0;
    $hbox_temp = Gtk2::HBox->new(FALSE, 5);

    foreach $row (@header_rows){
      #print ("$row \n");
      #create table header
      $table_header = Gtk2::Label->new("$row");    
      $hbox_temp->pack_start($table_header,FALSE,FALSE,0);
      @$size_group[$i++]->add_widget($table_header);
  }
    $hboxk->pack_start($hbox_temp,FALSE,FALSE,0);
    #end of table header
}


sub member
  {
          my @set = @_;
          my $m = pop (@set);
          my $iter;
          
          foreach $iter (@set){
              if ($iter == $m) {return TRUE;}
                  } 
          return FALSE;
      }

#######################################################################3
# CALLBACKS
######################################################################

#===CALLBACK===ACTION=
sub action_new{
    my $page = $notebook->get_current_page();
 
    action_new_keys() if ($page == TAB_KEYS);
    action_new_button() if ($page == TAB_MOUSE);
    signal_action_new() if ($page == TAB_SIGNAL);
    wheel_action_new() if ($page == TAB_WHEEL);
}


#===CALLBACK===OK===
sub action_ok
{
    action_apply();
    Gtk2->main_quit();    
}


#===CALLBACK===APPLY===
sub action_apply
{
    action_apply_keys();
    action_apply_mouse();

    signal_action_apply();
    options_action_apply();
    wheel_action_apply();
    module_action_apply();
}


##############################
# TODO#
#######
#desktop-bg-add

#  -font-available-list List all available fonts
#  -font-apply Apply font settings changes
#  -font-fallback-append OPT1 Append OPT1 to the fontset
#  -font-fallback-prepend OPT1 Prepend OPT1 to the fontset
#  -font-fallback-list List the fallback fonts in order
#  -font-fallback-remove OPT1 Remove OPT1 from the fontset

#  -font-default-set OPT1 OPT2 OPT3 Set textclass (OPT1) font (OPT2) and size (OPT3)
#  -font-default-get OPT1 List the default font associated with OPT1
#  -font-default-remove OPT1 Remove the default text class OPT1
#  -font-default-list List all configured text classes
#  -font-fallback-clear Clear list of fallback fonts

#  -dirs-list OPT1 List the directory of type specified by 'OPT1', try 'themes'
#  -dirs-list-append OPT1 Append the directory of type specified by 'OPT2 to the list in 'OPT1'
 # -dirs-list-prepend OPT1 Prepend the directory of type specified by 'OPT2 to the list in 'OPT1'
 # -dirs-list-remove OPT1 Remove the directory of type specified by 'OPT2 to the list in 'OPT1'