#!/usr/bin/perl 
$|=1;
use strict;
use File::Basename;
use Gtk2 '-init';
use Gtk2::SimpleList;
use List::Util qw(first max maxstr min minstr reduce shuffle sum);
my @open_modules;
my %modules;
my $sub_stop=0;
###global variables
my $home=$ENV{'HOME'};
my $self=__FILE__;
my $extra='/bin/burn_360';
$self=~s/$extra.*//g;
my $prefix=$self;
my $options_file=$home.'/.burn_360/.burn_360_opts';
my $dbfile=$home.'/.burn_360.db';
my $dbh=DBI->connect("dbi:SQLite:dbname=$dbfile","","",{AutoCommit=>1});

use DBI;

my @tables=$dbh->tables;

unless (grep /transcoding_orig/,@tables){
	$dbh->do("CREATE TABLE transcoding_orig (ord,comm,flags,ext,transname,type)") or die print $!,$dbh->errstr;

#my @init_opts=(
#['1','ffmpeg -v 2 -i ',' -target pal-vcd -y','en.mpg','VCD','Video'],
#['10','ffmpeg  -async 24 -v 2 -i ',' -target pal-dvd -y -s 352x288 -qscale 4 -bf 2 -g 15 -acodec mp2 -ac 2 -ab 224k  -me_range  63 -r 25 -mbd rd -trellis 2  -flags +mv0+qprd  -flags2 skiprd -vol 512 -aspect 4:3 ',' enn.vob','DVD Half qual','Video'],
#['11','ffmpeg -async 24 -i ',' -f flv -ar 44100 -ab 64 -ac 2 -acodec libmp3lame -qscale 10 -r 12 -s 352x288 -y','en.flv','Flash','Video'],
#['12','java -jar','/usr/share/java/ProjectX.jar','','Fix DVB','Video'],
#['13','ffmpeg -i ','','en.vob','DVD Music','Audio'],
#['14','ffmpeg -async 24 -v 2 -i ',' -target pal-dvd -y -s 352x288 -qscale 4 -bf 2 -g 15 -acodec mp2 -ac 2 -ab 224  -me_range  63 -mbd rd -trellis 2  -flags +mv0+qprd  -flags2 skiprd -vol 512 -aspect 4:3 ',' enn.vob','DVD HQ Music','Video'],
#['2','ffmpeg -v 2 -i ',' -f vcd -r 25 -s 352x288 -y -b 600k -ac 2 -ab 224 -ar 44100','en.mpg','VCD reduced size','Video'],
#['3','ffmpeg -async 24 -v 2 -i ',' -target pal-dvd -y  -s 352x288  -qscale 3 -bf 2 -g 15 -acodec mp2 -ac 2 -ab 224 -me_range 63  -vol 256 -aspect 4:3  ','en.vob','DVD half ','Video'],
#['4','ffmpeg -v 2 -i ',' -target pal-dvd -y -s 352x288 -aspect 4:3','en1.vob','DVD Standard','Video'],
#['5','ffmpeg -async 24 -v 2 -i ',' -qscale 3 -f avi -s 352x288 -y -acodec mp2 -ac 2 -ar 44100 -ab 224k   -aspect 4:3  -r 25 ','en.avi','avi dvd size ffmpeg native','Video'],
#['6','ffmpeg -v 2 -i ',' ','en.wav','Audio CD Files','Audio'],
#['7','ffmpeg -v 2 -i ',' -acodec vorbis -aq 60 -y ','en.ogg','ogg','Audio'],
#['8','ffmpeg -v 2 -i ',' -acodec libmp3lame -ab 192 -ar 48000 -ac 2 -vol 512 -y ','en.mp3','To mp3','Audio'],
#['9','ffmpeg -v 2 -i ',' -acodec amr_nb -ar 8000 -ac 2','en .amr','To amr Wb','Audio']);
my @init_opts=(
['1' , 'ffmpeg -v 35  -i ' , ' -c:v libx264 -preset fast -crf 22 -g 25  -c:a libmp3lame -threads 2 -vf scale="352:trunc(ow/a/2)*2",fps="fps= 25"  -y ' , '_en.mp4' , 'mp4' , 'Video'],
['10' , 'ffmpeg  -async 24 -v 35 -i ' , ' -target pal-dvd -y -s 352x288 -qscale 4 -bf 2 -g 15 -acodec mp2 -ac 2 -ab 224k  -me_range  63 -r 25     -vol 512 -aspect 4:3 ' , ' enn.vob' , 'DVD Half qual' , 'Video'],
['11' , 'ffmpeg -async 24 -i ' , ' -f flv -ar 44100 -ab 64 -ac 2 -acodec libmp3lame -qscale 10 -r 12 -s 352x288 -y' , 'en.flv' , 'Flash' , 'Video'],
['12' , 'java -jar' , '/home/mike/Project-X_0.91.0/ProjectX.jar' , '' , 'Fix DVB' , 'Video'],
['13' , 'ffmpeg -i ' , '' , 'en.vob' , 'DVD Music' , 'Audio]14' , 'ffmpeg -async 24 -v 2 -i ' , ' -target pal-dvd -y -s 352x288 -qscale 4 -bf 2 -g [15 -acodec mp2 -ac 2 -ab 224  -me_range  63 -mbd rd -trellis 2  -flags +mv0+qprd  -flags2 skiprd -vol 512 -aspect 4:3 ' , ' enn.vob' , 'DVD HQ Music' , 'Video'],
['2' , 'ffmpeg -v 35  -async 24 -i ' , ' -q:v 4 -c:v mpeg4 -vtag DX50 -vf  scale=352:288  -bf 1  -y  -f avi' , '_env.xvid' , 'xvid' , 'Video'],
['3' , 'ffmpeg -async 24 -v 35 -i ' , ' -target pal-dvd -y  -s 352 -qscale 3 -bf 2 -g 15 -acodec mp2 -ac 2 -ab 224k -me_range 63  -vol 256   ' , 'en.vob' , 'DVD half ' , 'Video'],
['4' , 'ffmpeg -v 2 -i ' , ' -target pal-dvd -y -s 352x288 -aspect 4:3' , 'en1.vob' , 'DVD Standard' , 'Video'],
['5' , 'ffmpeg     -v 35 -i ' , ' -qscale 3 -f avi -s 352x288 -y -acodec mp2 -ac 2 -ar 44100 -ab 224k   -aspect 4:3  -r 25 ' , 'en.avi' , 'avi dvd size ffmpeg native' , 'Video'],
['6' , 'ffmpeg -v 32 -i ' , ' -y -acodec pcm_s16le -ac 2 -f wav -ar 44100' , 'en.wav' , 'Audio CD Files' , 'Audio'],
['7' , 'ffmpeg -v 2 -i ' , ' -acodec vorbis -aq 60 -y ' , 'en.ogg' , 'ogg' , 'Audio'],
['8' , 'ffmpeg -v 32 -i ' , ' -acodec libmp3lame -ab 192 -ar 48000 -ac 2 -vol 512 -y ' , 'en.mp3' , 'To mp3' , 'Audio'],
['9' , 'ffmpeg -v 2 -i ' , ' -acodec amr_nb -ar 8000 -ac 2' , 'en .amr' , 'To amr Wb' , 'Audio'],
['15' , 'ffmpeg -async 24 -v 35 -i ' , '  -c:v libvpx  -crf 4 -vf scale=352:288 -b:v 300k -y' , 'en.webm' , 'webm' , 'Video'],
['16' , 'ffmpeg -async 24 -v 35 -i ' , '  -c:v libvpx -crf 6 -vf scale="352:-1",fps="fps= 20" -quality realtime -cpu-used 1 -g 25 -threads 2 -y' , 'ens1.webm' , 'webm small' , 'Video'],
['17' , 'ffmpeg -async 24 -v 35 -i ' , ' -q:v 4 -c:v mpeg4 -vtag divx   -y ' , 'ent.avi' , 'divx' , 'Video'],
['18' , 'ffmpeg  -v 35 -i ' , ' -c:v libx264 -preset ultrafast -crf 18 -g 25  -c:a copy  -movflags faststart -threads 2 -vf "scale=\'min(iw,720)\':trunc(ow/dar/2)*2",fps="fps= 20",setsar="1/1"   -y ' , '_enf.mp4' , 'fast mp4' , 'Video'],
['19' , 'ffmpeg -async 24 -v 35 -i ' , ' -c:v wmv2  -q:v 4  -threads 2 -vf scale=352:288 -y ' , 'enw2.wmv' , 'wmv2' , 'Video'],
['20' , 'ffmpeg -async 24 -v 35 -i ' , ' -c:v wmv3  -q:v 4  -threads 2 -vf scale=352:288 -y ' , 'rnw3.wmv' , 'wmv3' , 'Video'],
['21' , 'ffmpeg -v 35 -i ' , ' -c:v libx264 -preset fast -crf 25 -g 25  -c:a aac -strict -2  -af volume=2.5 -threads 2 -vf scale="352:trunc(ow/((1/sar)*dar)/2)*2",fps="fps= 20",setsar="1/1"  -af volume=2.5 -y ' , '_ens.mp4' , 'mp4 small' , 'Video'],
['22' , 'ffmpeg -async 24 -v 35 -i ' , ' -vcodec copy  -f avi -y -acodec copy      ' , 'enc.avi' , 'avi cut' , 'Video'],
['23' , 'ffmpeg  -v 35 -threads 4 -i ' , '-c:v libx264 -preset fast -crf 28 -g 25  -c:a  aac -b:a 128000  -threads 4 -af volume=2.5  -vf scale="352:trunc(ow/((1/sar)*dar)/2)*2",fps="fps= 20",setsar="1/1"   -strict -2 -y ' , '_envs.mp4' , 'mp4 vsmall' , 'Video'],
['24' , 'ffmpeg  -v 35 -threads 4 -i ' , '-c:v libx264 -preset fast -crf 25 -g 25  -c:a  aac -b:a 128000  -threads 4   -vf scale="352:trunc(ow/((1/sar)*dar)/2)*2",fps="fps= 20",setsar="1/1"   -strict -2 -y ' , '_envsc.mp4' , 'mp4 vsmall copy' , 'Video'],
['25' , 'ffmpeg  -v 35 -threads 4 -i ' , '-c:v libx264 -preset fast  -g 25  -c:a  aac -b:a 128000  -threads 4   -vcodec copy    -strict -2 -y ' , '_envsc2.mp4' , 'mp4copy' , 'Video']


);
my $ins=$dbh->prepare("INSERT INTO transcoding_orig VALUES(?,?,?,?,?,?)");
	foreach my $opt (@init_opts){
	
$ins->execute(@{$opt});
	}
}
	unless (grep /transcodings/,@tables){
		$dbh->do("CREATE TABLE transcodings (ord,comm,flags,ext,transname,type)") or die print $!,$dbh->errstr;
	$dbh->do("INSERT INTO transcodings SELECT * from transcoding_orig");
	}


unless (grep /config/,@tables){
	$dbh->do("CREATE TABLE config (option,value)") or die print $!,$dbh->errstr;
foreach my $opt ('dir','broadcast'){
$dbh->do("INSERT into config (option) VALUES ('$opt')");
}

}
unless (grep /broadcast/,@tables){
	$dbh->do("CREATE TABLE broadcast (ind,vtype,framerate,target,size)") or die print $!,$dbh->errstr;
$dbh->do("INSERT INTO broadcast VALUES (1,'PAL','25','pal_dvd','720x576')");
$dbh->do("INSERT INTO broadcast VALUES (2,'NTSC','29','ntsc_dvd','704x576')")
}
unless (grep /dvds/,@tables){
	$dbh->do("CREATE TABLE dvds (disc,vob,title,titord,date)") or die print $!,$dbh->errstr;
}
my %broadcast=(0=>{type=>'',fr=>'',target=>''},
		1=>{type=>'PAL',fr=>'25',target=>'pal-dvd',size=>'720x576'},
		2=>{type=>'NTSC',fr=>'29',target=>'ntsc-dvd',size=>'704x576'}
		);

my %options=&options_get;
my $pid;
my $dir1=$options{'dir'};
my @pids;
my %files;
my $window=Gtk2::Window->new('toplevel');
my $second_title;


sub disk_chk {
my $options=shift;
my @files_stat= stat $options;
my $part;
my @mounts=`df -m`;
shift @mounts;
my %mount_points;
	foreach my $dev1 (@mounts){
		my @dev=split /\s+/, $dev1;
		my @inode=stat $dev[5];
		$mount_points{$dev[5]}=$inode[0];
		}

	foreach my $keys (keys %mount_points){
		$part=$keys if $files_stat[0] eq $mount_points{$keys}
		}
my @cap=split /\s+/,`df -m|grep $part`;

	if ($cap[4]=~/^100/) {
		return 0 ;
		}
	else {
		return 1
	}
}

## Menu Setup ##
my @entries = (
#file menus  - now deprecated, all functions ran from button layout
[ "FileMenu",undef,"_File"],
[ "Encode Files",    'gtk-open',  "_Encode Files",   "<control>E", "Encode Files",    \&encoder_opts ],
[ "Capture files from VCD/DVD/Capture Device",   'gtk-cdrom', "_Capture - Get files from VCD/DVD/Capture Device",  "<control>R", "Rip from media",       \&capture_opts ],
[ "Create DVD",   'gtk-cdrom', "_Create DVD",  "<control>B", "Create DVD",  \&dvd_opts ],
[ "Close",   'gtk-quit', "_Quit",  "<control>Q", "Quit",sub { foreach my $pid (@pids){kill 15 ,$pid};Gtk2->main_quit;}],
[ "EditMenu",undef,"_Edit"],
[ "Modify Encoding",    'gtk-preferences',  "_Modify Encoding",   "<alt>M", "Modify", sub{&pref_disable}],


[ "HelpMenu",undef,"_Help"],
[ "Help",    'gtk-help',  "_Help",   "<alt>H", "Help", \&help ],
[ "About",    'gtk-about',  "_About",   "<alt>A", "About", \&about ],

);

my $ui_basic = "<ui>
<menubar name='MenuBar'>
    <menu action='FileMenu'> 

    <menuitem action='Capture files from VCD/DVD/Capture Device' position='top'/>
    <separator/>
    <menuitem action='Encode Files' position='2'/>
    <separator/>
    <menuitem action='Create DVD' position='3'/>
 <menuitem action='Close'/>
   </menu>
<menu action='EditMenu'>
<menuitem action='Modify Encoding' position='1'/>
   </menu>
 <menu action='HelpMenu'>
<menuitem action='Help' position='1'/>
<menuitem action='About' position='2'/>
   </menu>
   </menubar>
</ui>";

sub pref_disable {
my $menu_act='yes';
	foreach my $mod (@open_modules){
	$menu_act ='no' if $mod eq 'encode'
	}
	if ($menu_act eq 'yes'){
		&mod(undef)
		}
	else {
		my $warn=Gtk2::MessageDialog->new($window,'destroy-with-parent','info','ok',"You have loaded the Encoding module\nPlease change settings by pressing the \"Amend Presets\" button");
		$warn->run;
		$warn->destroy;

		}
}

## GUI Base Setup ##
my $window=Gtk2::Window->new('toplevel');
my $window_vbox=Gtk2::VBox->new(0,0);
my $blurb_frame=Gtk2::Frame->new;
$blurb_frame->set_shadow_type('out');
my $blurb_box=Gtk2::HBox->new(0,0);
$blurb_box->set_name('blurb_box');
my $blurb_im=Gtk2::Image->new_from_file("$prefix/share/burn_360/icons/burn_360.png");
my $blurb_im1=Gtk2::Image->new_from_file("$prefix/share/burn_360/icons/package_multimedia.png");
my $blurb_lab=Gtk2::Label->new();
$blurb_lab->set_markup("<span size='xx-large'>Combined Multi-media Capture, Encoding\n and media creation tool for Linux</span>");
$blurb_lab->set_justify('center');
&pack_widgets($blurb_box,[$blurb_im,$blurb_lab,$blurb_im1],[1,1,0]);


my $class='normal';
my $border = Gtk2::Gdk::Color->new (62259,62200,20316);

$blurb_frame->modify_bg("$class",$border);
$blurb_frame->set_name('blurb_frame');
$blurb_frame->add($blurb_box);
$blurb_box->show_all;

$window->set_default_size (1200,600);
$window->set_title('Burn 360');
$window->set_default_icon_from_file("$prefix/share/burn_360/icons/burn_360.png");
$window->set_urgency_hint(1);
$window->set_position('center');
$window -> signal_connect ('delete_event' => sub {
					foreach my $pid (@pids){kill 15,$pid} Gtk2->main_quit;
					});

### Menu Setup - deprecated ###
my $uimanager = Gtk2::UIManager->new;
my $accelgroup = $uimanager->get_accel_group;
$window->add_accel_group($accelgroup);
my $actions_basic = Gtk2::ActionGroup->new ("actions_basic");
$actions_basic->add_actions (\@entries, undef);
$uimanager->insert_action_group($actions_basic,0);
$uimanager->add_ui_from_string ($ui_basic);
my $menubar = $uimanager->get_widget('/MenuBar');
&pack_widgets($window_vbox,[$menubar,$blurb_frame],[0,0,0]);
#$window_vbox->pack_start($blurb_frame,0,0,0);
$window_vbox->set_name('vbox');
$window_vbox -> show_all();
$window->add($window_vbox);

my $def=$options{'dir'};
	if (! -e $def){
		my $dir_sel=Gtk2::Dialog->new('Please Set Save Directory',$window,'modal');
		$dir_sel->set_title('Please Set Save Directory');
		$dir_sel->set_position('center');
		$dir_sel->set_modal(1);
		$dir_sel->set_transient_for($window);

		my $dir_vbox=Gtk2::VBox->new(0,0);
		my $dir_btn=Gtk2::Button->new('Please select');
		my $dir_lab=Gtk2::Label->new("Welcome to Burn 360 - a program to get videos\nfrom any video source(DVD's,VCDs or capture source\nsuch as TV card) and creating DVD's (on DVD,s or CD's).\nIn addition it encodes most video and audio files.\n\nTo Commence using the programme you must \nfirst choose a default directory to save to. \n\nThis should have sufficient space for any \nfiles you wish to create (at least 700MB free)");
			$dir_btn->signal_connect(
						'clicked',sub{&selection('Select Default Directory','select-folder');$dir_sel->destroy}
						);
		&pack_widgets($dir_sel->vbox,[$dir_lab,$dir_btn],[0,0,5]);
		$dir_sel->show_all();
		}

my $prog_hbox1=Gtk2::HBox->new(0,0);
my $prog_vbox1=Gtk2::VBox->new(0,0);
$prog_hbox1->set_name('prog_hbox1');
$prog_vbox1->set_name('prog_vbox1');


## Create Tool Buttons ##

# Encode Button creation #
	my $encode_vbox=Gtk2::VBox->new(0,0);
	my $encode_btn=Gtk2::Button->new();
	my $encode_label=Gtk2::Label->new("Encode");
	my $encode_image=Gtk2::Image->new_from_stock('gtk-open','small-toolbar');
	$encode_vbox->add($encode_image);
	$encode_vbox->add($encode_label);
	$encode_btn->add($encode_vbox);
	$encode_btn->signal_connect('clicked',sub{
						&encoder_opts;
						$second_title=$second_title.'/Encode';
						$second_title=~s/^\///;
						$window->set_title("Burn 360 - ".$second_title);

						});
	my $fix_button=Gtk2::Button->new();

# Capture Button Creation #
	my $rip_btn=Gtk2::Button->new();
	my $rip_vbox=Gtk2::HBox->new(0,0);
	my $rip_hbox=Gtk2::VBox->new(0,0);

	my $rip_model=Gtk2::TreeStore->new('Glib::String');
	my $rip_combo=Gtk2::ComboBox->new_with_model($rip_model);
	my @captures=("Optical Disk","TV Card","Screen");
		foreach my $cap (@captures){
			my $iter=$rip_model->append(undef);
			$rip_model->set($iter,0,$cap);
			}

	my $renderer=Gtk2::CellRendererText->new;
	$rip_combo->pack_start($renderer,'TRUE');
	$rip_combo->add_attribute($renderer, text => 0);

	my $rip_label=Gtk2::Label->new("Get Video from\nexternal Source");
	my $rip_image1=Gtk2::Image->new_from_stock('gtk-cdrom','small-toolbar');
	my $rip_image2=Gtk2::Image->new_from_stock('gtk-go-forward','small-toolbar');
	$rip_vbox->pack_start($rip_image1,1,1,0);
	$rip_vbox->pack_start($rip_image2,1,1,0);
	$rip_hbox->add($rip_vbox);
	$rip_hbox->add($rip_label);
	$rip_btn->add($rip_hbox);
	$rip_combo->signal_connect('changed',sub{
						my $iter=$rip_combo->get_active_iter;&capture_opts($rip_model->get_value($iter,0));
						$second_title=$second_title.'/'.$rip_model->get_value($iter,0);
						$second_title=~s/^\///;
						$window->set_title("Burn 360 - ".$second_title);
						});
	$rip_combo->add($rip_btn);

# Create DVD creation Button #
	my $dvd_btn=Gtk2::Button->new;
	my $dvd_combo=Gtk2::ComboBox->new_text();
	my $dvd_vbox=Gtk2::HBox->new(0,0);
	my $dvd_hbox=Gtk2::VBox->new(0,0);
	my $dvd_label=Gtk2::Label->new("Create DVD");
	my %dvd_actions=("New DVD from Vobs"=>'dvd_setup',"DVD from existing File System"=>'dvd_from_dir', "DVD from Image"=>'dvd_from_image',"Modify DVD from xml file"=>'dvd_modify');
	foreach my $keys (keys %dvd_actions){
			$dvd_combo->append_text($keys)
			}

	my $dvd_image1=Gtk2::Image->new_from_stock('gtk-cdrom','small-toolbar');
	my $dvd_image2=Gtk2::Image->new_from_stock('gtk-go-forward','small-toolbar');
	$dvd_vbox->pack_start($dvd_image2,1,1,0);
	$dvd_vbox->pack_start($dvd_image1,1,1,0);
	$dvd_hbox->add($dvd_vbox);
	$dvd_hbox->add($dvd_label);
	my $dvd_frame=Gtk2::Frame->new;
	$dvd_frame->set_shadow_type('out');
	$dvd_btn->add($dvd_hbox);
	$dvd_combo->signal_connect('changed',sub{&dvd_opts($dvd_combo->get_active_text,\%dvd_actions);
						$second_title=$second_title.'/'.$dvd_combo->get_active_text;
						$second_title=~s/^\///;
						$window->set_title("Burn 360 - ".$second_title);
						});
	$dvd_combo->add($dvd_btn);

# Create Save Directory Button #
	my $dir_label=Gtk2::Label->new();
	my $dir_save_label=Gtk2::Label->new();
	my $dir_save_label_text=&dir_sel;
	my $dir_lable_text="Set Directory \nto save work\nCurrent Directory is ";
	$dir_label->set_markup("<span weight= 'bold'>$dir_lable_text </span>");
	$dir_label->set_text($dir_lable_text);
	my $dir_image=Gtk2::HBox->new(0,0);
	my $dir_im=Gtk2::Image->new_from_stock('gtk-save','small-toolbar');
	my $dir_vbox=Gtk2::VBox->new(0,0);
	&pack_widgets($dir_vbox,[$dir_label,$dir_save_label],[0,0,0]);
	&pack_widgets($dir_image,[$dir_im,$dir_vbox],[0,0,0]);

	my $btn_set = Gtk2::Button->new();
	$btn_set->set_focus_on_click(0);
	$btn_set->set_relief('half');
	$btn_set->add($dir_image);
	$btn_set->signal_connect('clicked' ,  sub{
						selection('Select Directory','select-folder',$dir_save_label);

						});
# Video Type Button #
	my $broadcast=Gtk2::ComboBox->new_text();
		foreach my $line ("Select Broadcast\nType",'PAL',"NTSC"){
				$broadcast->append_text($line);
				}

	$broadcast->set_active('0');
	$broadcast->signal_connect('changed',sub{
					$options{'broadcast'}=$broadcast->get_active;
$dbh->do("UPDATE config set value='$options{'broadcast'}' where option = 'broadcast'");


						});


## Add small-toolbar (Vertical) ##

my $prog_hbox=Gtk2::HBox->new(0,0);
my $tool_vbox=Gtk2::VBox->new(0,0);
my $prog_vbox=Gtk2::VBox->new(0,0);
$prog_hbox->set_name('prog_hbox');
$prog_vbox->set_name('prog_vbox');
$prog_vbox -> show_all;
my $scroll_win=Gtk2::ScrolledWindow->new ();

&pack_widgets($tool_vbox,[$btn_set,$broadcast,$rip_combo,$encode_btn,$dvd_combo],[0,0,0]);

$tool_vbox->set_name('tool_vbox');
$prog_hbox1->pack_start($tool_vbox,0,0,5);

## Add Scrolling Programme Window ##

$scroll_win->add_with_viewport ($prog_vbox);
$scroll_win->set_name('scroll_win');
$prog_hbox1->pack_start($scroll_win,1,1,5);
$window_vbox->pack_start($prog_hbox1,1,1,5);
$window_vbox->show_all;
$window->show();
Gtk2->main();
0;

## Help Menu Subs ##

sub help {
my $help_window=Gtk2::Window->new('toplevel');
$help_window->set_title('Help');
$help_window->set_default_size (800,600);
my $help_scroll=Gtk2::ScrolledWindow->new();
my $help_vbox=Gtk2::VBox->new(0,5);
$help_window->add($help_vbox);
open (HELP,"<","$prefix/share/doc/burn_360/README.txt");
my $help_file="$prefix/share/doc/burn_360/README.html";
my @help=<HELP>;
my $help_buff=Gtk2::TextBuffer->new();
$help_buff->create_tag("word_wrap", wrap_mode => 'word');
my $help_view=Gtk2::TextView->new();

	foreach my $help (@help){
		my $iter = $help_buff->get_iter_at_offset (-1);
		$help_buff->insert($iter,$help);
		}

$help_buff->apply_tag_by_name("word_wrap",$help_buff->get_bounds);
$help_view->set_buffer($help_buff);

my @html= qw(epiphany konqueror mozilla firefox galeon);
my @path=split /:/,$ENV{'PATH'};
my @brows;
	foreach my $path1 (@path){
		foreach my $brows (@html){
			if (-e "$path1/$brows"){
				push (@brows,$brows)
				}
			}
		}

my $brows_comb=Gtk2::ComboBox->new_text();
my $desc="To view this in \nhtml formatted version, \nselect your favourite browser";
unshift (@brows,$desc);
	foreach my $brows (@brows){
		$brows_comb->append_text($brows);
		}

$brows_comb->set_active(0);
my $brows_layout=Gtk2::Table->new(1,5,0);
$brows_layout->attach_defaults($brows_comb,2,3,0,1);
$brows_layout->set_col_spacing(0,20);
$brows_layout->set_col_spacing(1,300);
$brows_layout->set_col_spacing(2,300);
$brows_layout->set_col_spacing(3,20);
$brows_comb->signal_connect('changed',sub{
					&browser($brows_comb,$help_file)
					});
my $brows_frame=Gtk2::Frame->new();
$brows_frame->add($brows_layout);
$brows_frame->set_name('brows_frame');

$help_scroll->add($help_view);
$help_vbox->pack_start($brows_frame,0,1,0);
$help_vbox->pack_start($help_scroll,1,1,0);
$help_window->show_all();

}

sub browser {
my ($brows_comb,$help)=@_;
my $browser=$brows_comb->get_active_text();
system("$browser $help &");
}

sub about {
my $about_window=Gtk2::Window->new('toplevel');
$about_window->set_title('About');
my $about_vbox=Gtk2::VBox->new(0,5);
my $about_label1=Gtk2::Label->new("Burn 360 v0.9.0");
my $about_label2=Gtk2::Label->new("Copyright 2006 - 2011 Mike Martin\nmike\@redtux.org.uk");
my $image=Gtk2::Image->new();
$image->set_from_file("$prefix/share/burn_360/icons/burn_360.png");
&pack_widgets($about_vbox,[$about_label1,$image,$about_label2],[1,1,5]);
$about_window->add($about_vbox);
$about_window->set_default_size (200,300);
$about_window->show_all();
}


## Program Subs ##

sub mod {
my ($video_type,$encode)=@_;
my $mod_win=Gtk2::Window->new('toplevel');
$mod_win->set_default_size(500,-1);
my $mod_vbox=Gtk2::VBox->new(0,0);
my $mod_hbox=Gtk2::HBox->new(0,0);
my $mod_label=Gtk2::Label->new();
my $add_encode_type_btn=Gtk2::Button->new('Add new Category');
my $amend_encode_type_btn=Gtk2::Button->new(' Changes');
my $delete_encode_type_btn=Gtk2::Button->new('Delete Record');
$mod_label->set_text(&word_wrap("Please see the available programme opts for converting video files - amend as required ",'98'));
$mod_win->set_title("Modify Encoding Options");
my $scrollopts=Gtk2::ScrolledWindow->new();

Gtk2::SimpleList->add_column_type( 'Combo',
                     type     => 'Glib::Scalar',
                     renderer => 'Gtk2::CellRendererCombo',
                     attr     => sub {
                          my ($treecol, $cell, $model, $iter, $col_num) = @_;
                          my $info = $model->get ($iter, $col_num);
                          $cell->set (text => $info);
                     }
                );

my $mod_model=Gtk2::SimpleList->new('ID'=>'int','program'=>'text','main_opts'=>'text','extension'=>'text','description'=>'text','type'=>'Combo');
my $editopts=$dbh->selectall_arrayref("select * from transcodings order by cast(ord as integer)");
foreach my $flags (@{$editopts}){
$flags->[2]=&word_wrap($flags->[2],60);

}
$mod_model->set_data_array($editopts);
$mod_vbox->pack_start($mod_label,0,1,0);
#$scrollopts->add($mod_model);

$mod_vbox->pack_start($scrollopts,1,1,0);
#$mod_vbox->pack_start($mod_model,0,0,0);
for (0..5){
$mod_model->set_column_editable($_,1)
}

$mod_model->set_headers_clickable(1);
my ($id_col,$prog_col,$opts_col,$ext_col,$desc_col,$category);
my $col_cnt=0;
my ($hpath,$hfocus,$mod_id,$hrow_ref);

$mod_model->signal_connect('cursor_changed'=>sub{
			($hpath,$hfocus)= $mod_model->get_cursor;
			$hrow_ref = $mod_model->get_row_data_from_path ($hpath);
			$mod_id=$hrow_ref->[0];
			}
			);
my %mod=(0=>{col=>$id_col,field=>'ord'},
	1=>{col=>$prog_col,field=>'comm'},
	2=>{col=>$opts_col,field=>'flags'},
	3=>{col=>$ext_col,field=>'ext'},
	4=>{col=>$desc_col,field=>'transname'}
);






	foreach my $col ($id_col,$prog_col,$opts_col,$ext_col,$desc_col,$category){
	$col=$mod_model->get_column($col_cnt);
	$col->set_sort_column_id($col_cnt);
	$col_cnt++;
	}
#my $colno=0;
	foreach my $col_ordk (keys %mod){
		my $col_ord=$mod_model->get_column($col_ordk);
		$col_ord->set_resizable(1);
		my $col_rend=$col_ord->get_cell_renderers;
		$col_rend->signal_connect('edited'=>sub{
		my $val=$hrow_ref->[$col_ordk];
		my $id=$hrow_ref->[0];
$val=~s/\n//g;
$val=~s/'/''/g;
		my $sql=$dbh->do("update transcodings set $mod{$col_ordk}->{field} ='$val' where ord='$id' or ord=$id");
		}
		);
		#$colno++

			}

#$col_cnt;
$mod_model->set_reorderable(1);



my $catlist=Gtk2::ListStore->new('Glib::String');
my $cat_rend=$category->get_cell_renderers;
	foreach my $list (sort 'Video','Audio','Fix'){
		$catlist->set($catlist->append,0,$list);
		}

$cat_rend->set(model=>$catlist,text_column=>0,editable=>'false');

my $modeltable=$mod_model->get_model;
$cat_rend->signal_connect('edited'=>sub{
			my ($path,$focus)= $mod_model->get_cursor;
			my $row_ref = $mod_model->get_row_data_from_path ($path);
			my $id=$row_ref->[0];
			my ($cell, $text_path, $val) = @_;
					$modeltable->set (
						$modeltable->get_iter_from_string ($text_path),
						5, $val
			);
$dbh->do("update transcodings set type= '$val' where cast(ord as integer) =$id");
			});

$mod_model->signal_connect('button-press-event'=>sub{
		my ($widget, $event) = @_;               
		return 0 unless $event->button == 3;
		my $action_menu=Gtk2::Menu->new;
		my $itemdel=Gtk2::MenuItem->new('Delete preset');
		my $itemins=Gtk2::MenuItem->new('Add preset');
		$action_menu->append($itemdel);
		$action_menu->append($itemins);
		$itemdel->show;
		$itemins->show;

				$action_menu->popup(
				        undef, # parent menu shell
				        undef, # parent menu item
				        undef, # menu pos func
				        undef, # data
				        $event->button,
				        $event->time);
			my ($path,$focus)= $mod_model->get_cursor;
		my $row_ref = $mod_model->get_row_data_from_path ($path);
		$itemdel->signal_connect('activate'=>sub{
		$dbh->do("delete from transcodings where ord='$row_ref->[0]' or ord=$row_ref->[0]");
		my @index= $mod_model->get_selected_indices;
		no strict 'refs';
		splice @{$mod_model->{data}},$index[0],1 ;
		}
		);
		$itemins->signal_connect('activate'=>sub{
		$dbh->do("insert into transcodings select max(cast (ord as integer))+1,NULL,NULL,NULL,NULL,NULL from transcodings");
my $idnew=$dbh->selectcol_arrayref("select max(cast (ord as integer)) from transcodings")->[0];
		my @index= $mod_model->get_selected_indices;
		no strict 'refs';
		push @{$mod_model->{data}},$idnew ;
		}
);
}
);
no strict 'refs';
#	foreach my $keys (sort {$a<=>$b} keys %options){
#		if ($keys ne 'broadcast' and $keys ne 'dir'){

#			my @opts1=($keys,$options{$keys}->{prog},$options{$keys}->{opt},$options{$keys}->{ext},#$options{$keys}->{vtype},$options{$keys}->{type});
#			$opts1[2]=&word_wrap($opts1[2],'60');
#			my $ref=\@opts1;
#			push (@{$mod_model->{data}},$ref)
#			}
#		}
#&pack_widgets($mod_hbox,[0,0,5]);

$mod_vbox->pack_start($mod_hbox,0,0,0);

#$add_encode_type_btn->signal_connect('clicked',sub{push (@{$mod_model->{data}},[undef,undef,undef,undef,undef])});
#$delete_encode_type_btn->signal_connect('clicked',sub{my @list=$mod_model->get_selected_indices;splice @{$mod_model->{data}},$list[0],1;});
#$amend_encode_type_btn->signal_connect('clicked',sub{
#	%options=&update_opts(@{$mod_model->{data}});&opts($video_type);
#		if ($encode){
#			foreach my $encodes ($encode->get_children){
#				$encode->remove($encodes) if $encodes->get_name eq 'encode'
#				}
#		};
#	$mod_win->destroy 
#	});
$scrollopts->add_with_viewport($mod_model);
$mod_win->add($mod_vbox);
$mod_win->maximize;
$mod_win->show_all();
$mod_win->signal_connect('delete-event'=>sub{

%options=&options_get;
$mod_win->destroy;

}
);
return 1
}

#sub update_opts {
#my $update=\@_;
#my @update;
#no strict 'refs';

#	foreach my $upd (@{$update}){
#		my @upd;
#		foreach my $updhash (@{$upd}){
#			$updhash=~s/\n//g;
#			push (@upd,$updhash);
#			}
#		$upd=\@upd;
#		push(@update,$upd);
#			foreach my $key (keys %options){
#				if ($key ne 'dir' and $key ne 'broadcast'){ 
#					delete $options{$key} if $key ne ${$upd}[0]
#					}
#				}
#		}

#no strict 'refs';
#	foreach my $upd (@update){
#			$options{@{$upd}[0]}={prog=>$upd->[1],opt=>$upd->[2],ext=>$upd->[3],vtype=>$upd->[4],type=>$upd->[5]} ;
#			}

#&save_options;
#return %options;
#}

sub options_get {
my %options=%{$dbh->selectall_hashref("select ord,comm as prog,flags as opt,ext,transname as vtype,type from transcodings where transname is not null",'ord')};
my %consql=%{$dbh->selectall_hashref("select * from config",'option')};
foreach my $key (keys %options){
#$options{$key}=undef;
}

foreach my $key (keys %consql){
$options{$key}=$consql{$key}->{'value'};
}

return %options;
}



sub encoder_opts {
my $subname='encode';

	if (! exists $modules{$subname}){
		$modules{$subname}=[];
		my $btn_encode_open_lab = "\nAdd file to\n be Encoded\n";
		my $btn_encode_title_lab = 'Encoding Selection Actions';
		my $subname=['encode','encode'];
		setup_module($btn_encode_open_lab ,  $btn_encode_title_lab,$subname);
		}

}

sub capture_opts {
my $sub=shift;
my $tag1=grep /$sub/,@open_modules;
	if ($tag1 eq 0){
		push (@open_modules,$sub);
		my $btn_burn_title_lab="Capture Video from $sub  ";
		my $subname=['capture',$sub];
		$subname->[1]='DVD' if $sub=~/Optical/;
		setup_module(undef ,  $btn_burn_title_lab,$subname);
		}
}

sub dvd_opts {
my ($opt,$subs)=@_;
%options=&options_get;
my $subname=['DVD Create',$$subs{$opt}];
my $label;

	foreach my $keys (keys %$subs){
	$label = $keys if $$subs{$keys} eq $subname;
	}


	if ($subname eq 'dvd_modify'){
		if (exists $modules{$subname}){
			my $widget=$modules{$subname}->[0][0];
			$widget->destroy ;
			delete $modules{$subname}
			}
		}

	if (! exists $modules{$subname}){
		$modules{$subname}=[];
		my $btn_burn_open_lab="Add file to\n be added to DVD";
		my $btn_dvd_title_lab=$label;
		setup_module($btn_burn_open_lab , $btn_dvd_title_lab,$subname) if defined $subname;
		}
}

sub pack_widgets {
my ($parent,$child,$pack_opts)=@_;
my $type = ref $child;
	if ($type=~/ARRAY/){
	my @opts=split /,/,$pack_opts;
	foreach my $w ( @{$child}){
	$parent->pack_start($w, $pack_opts->[0],$pack_opts->[1],$pack_opts->[2]);
	}
	}
	else {
	no strict 'refs';
		foreach my $w (sort {$a<=>$b} keys %{$child}){
			$parent->pack_start($$child{$w}[0],$$child{$w}[1],$$child{$w}[2],$$child{$w}[3]);
			}
	}
}

sub create_widgets {
my $widgets=shift;
my %widgets=%{$widgets};
my %widget;
my $screen=Gtk2::Gdk::Screen->get_default;
my $ratio= $screen->get_width/$screen->get_height;
my $scale=Gtk2::Pango->scale;
	foreach my $keys (sort {$a<=>$b} keys %widgets){
	no strict 'refs';
		if (length($widgets{$keys}->{wname})<1){
		$widgets{$keys}->{wname}=$keys
		}
		my $action=$widgets{$keys}->{action};
			my $w=eval($keys);
			$w=$widgets{$keys}->{type}->$action(@{$widgets{$keys}->{opts}}) or die print $!;
			$w->set_name($widgets{$keys}->{wname}) ;
			$widgets{$keys}->{height}=0 if length($widgets{$keys}->{height}) lt 1;
			my ($width,$height)=&width($w,$widgets{$keys}->{width},$widgets{$keys}->{height}) if defined $widgets{$keys}->{width};
			$w->set_size_request($width,$height) if defined $widgets{$keys}->{width};
		$widget{$keys}=$w;
		
		}

return \%widget;
}
sub width {
my ($w,$width,$height)=@_;
my ($width1,$height1);
if (defined $w){
my @length;
my $label=Gtk2::Label->new;
for (1..$width){
push  @length,"X";
}

$label->set_text(join '',@length);

my $context=$label->get_pango_context;
my $fontd=$context->get_font_description;
($width1,$height1,undef)=$label->get_layout->get_pixel_size();
if ($height==0){
$height1='-1';
}
else {
$height1=$height*$height1
}
}
return $width1,$height1;


}


sub setup_module {
my ($sel_opts_open_lab , $sel_opts_title_lab,$subname) = @_;
my %widgets=(
	'open_hbox'=>{type=>'Gtk2::HBox',action=>'new',opts=>[0,0],wname=>'open_hbox'},
	'encode_open_lab'=>{type=>'Gtk2::Label',action=>'new',opts=>[$sel_opts_open_lab],wname=>'open_label'},
	'image'=>{type=>'Gtk2::Image',action=>'new_from_stock',opts=>['gtk-open','small-toolbar'],wname=>'file_hbox'},
	'delay'=>{type=>'Gtk2::Entry',action=>'new',opts=>[],wname=>'delay',width=>4},
	'delay_label'=>{type=>'Gtk2::Label',action=>'new',opts=>["Delay action in Minutes"],wname=>'delay_label'},
	'delay_hbox'=>{type=>'Gtk2::HBox',action=>'new',opts=>[0,0],wname=>'delbox'},
	'btn_open'=>{type=>'Gtk2::Button',action=>'new',opts=>[],wname=>'btn_open'},
	'sel_opts_frame'=>{type=>'Gtk2::Frame',action=>'new',opts=>[],wname=>'sel_opts_frame'},
	'sel_opts_mod_lab'=>{type=>'Gtk2::Label',action=>'new',opts=>[$sel_opts_title_lab],wname=>'mod_opts_label'},
	'title_frame'=>{type=>'Gtk2::Frame',action=>'new',opts=>[],wname=>'title_frame'},
	'sel_opts_hbox'=>{type=>'Gtk2::HBox',action=>'new',opts=>[0,0],wname=>'sel_opts_hbox'},
	'sel_opts_vbox'=>{type=>'Gtk2::VBox',action=>'new',opts=>[0,1],wname=>'sel_opts_vbox'},
	'enc_hbox'=>{type=>'Gtk2::HBox',action=>'new',opts=>[0,0],wname=>'enc_hbox'},
	'video_type'=>{type=>'Gtk2::ComboBox',action=>'new_text',opts=>[],wname=>'video_type'}
	);

my %widget=%{&create_widgets(\%widgets)};
my $video_type;
$widget{delay}->set_text(0);
&pack_widgets($widget{delay_hbox},[$widget{delay_label},$widget{delay}],[0,0,0]) if $subname->[0]=~/encode/i;
&pack_widgets($widget{open_hbox},[$widget{image},$widget{encode_open_lab}],[0,0,0]);	
$widget{sel_opts_frame}->set_shadow_type('etched-out');
$widget{sel_opts_mod_lab}->set_markup("<span weight='600'> $sel_opts_title_lab </span>" );
$widget{title_frame}->add($widget{sel_opts_mod_lab});
$widget{btn_open}->set_relief('half');
$widget{btn_open}->add($widget{open_hbox});
$widget{sel_opts_vbox}->pack_start($widget{title_frame},0,0,0);


	if ($subname->[0] eq 'encode'){
		my %widgets_encode=('encode_vbox'=>{type=>'Gtk2::VBox',action=>'new',opts=>[0,0],wname=>'encode_vbox'},
		'video_hbox'=>{type=>'Gtk2::HBox',action=>'new',opts=>[0,0],wname=>'video_hbox'},
		'open_vbox_container'=>{type=>'Gtk2::VBox',action=>'new',opts=>[0,0],wname=>'open_vbox_container'},
		'video_hbox_spacer'=>{type=>'Gtk2::HBox',action=>'new',opts=>[0,0],wname=>'video_hbox_spacer'},
		'action_frame'=>{type=>'Gtk2::Frame',action=>'new',opts=>[],wname=>'action_frame'},
		'opts_mod'=>{type=>'Gtk2::Button',action=>'new',opts=>['Amend Presets'],wname=>'opts_mod'},
		);

		my %widgete=%{&create_widgets(\%widgets_encode)};
		$widget{video_type}->set_name('video_type');
		&opts($widget{video_type});
		$widgete{opts_mod}->signal_connect('clicked'=>sub{
					&mod($widget{video_type},$widgete{encode_vbox});
					});

		$widget{video_type}->signal_connect('changed'=>sub{
					&encode($widget{video_type},$widgete{encode_vbox},$widget{sel_opts_vbox},$widget{delay}) 
					});
		$widget{btn_open}->set_size_request(-1,100);
		&pack_widgets($widgete{video_hbox},[$widget{video_type},$widgete{opts_mod}],[0,0,0]);
		&pack_widgets($widgete{encode_vbox},[$widgete{video_hbox},$widget{delay_hbox}],[0,0,0]);
		&pack_widgets($widgete{open_vbox_container},[$widget{btn_open}],[0,0,6]);
		$widgete{action_frame}->add($widgete{encode_vbox});
		$widget{sel_opts_hbox}->pack_start($widgete{open_vbox_container},0,0,6);
		$widget{sel_opts_hbox}->pack_start($widgete{action_frame},0,0,2);
		}

	elsif ($subname->[0] =~/DVD/){
		my %widgets_dvd=(

			'dvd_titles_btn'=>{type=>'Gtk2::Button',action=>'new_with_label',opts=>["Update Title Descriptions for DVD"],wname=>''},
			'chap_length_label'=>{type=>'Gtk2::Label',action=>'new',opts=>["Chapter Length"],wname=>''},
			'chap_length'=>{type=>'Gtk2::ComboBox',action=>'new_text',opts=>[],wname=>''},
			'cd_work_label'=>{type=>'Gtk2::Label',action=>'new',opts=>['CD Workaround'],wname=>''},
			'cd_work_btn'=>{type=>'Gtk2::CheckButton',action=>'new',opts=>[],wname=>''},
			'dvd_title_lable'=>{type=>'Gtk2::Label',action=>'new',opts=>["Volume Label for DVD"],wname=>''},
'prev_cmd'=>{type=>'Gtk2::Entry',action=>'new',opts=>[],wname=>'prev_cmd'},
			'dvd_title'=>{type=>'Gtk2::Entry',action=>'new',opts=>[],wname=>'',width=>32},
			'home_menu_label'=>{type=>'Gtk2::Label',action=>'new',opts=>["Image File for Menu"],wname=>''},
			'home_menu'=>{type=>'Gtk2::Entry',action=>'new',opts=>[],wname=>''},
			'home_menu_chg'=>{type=>'Gtk2::Button',action=>'new',opts=>['Change jpeg for Menu'],wname=>''},
			'titles_vbox'=>{type=>'Gtk2::VBox',action=>'new',opts=>[0,1],wname=>''},
			'file_vbox'=>{type=>'Gtk2::VBox',action=>'new',opts=>[0,0],wname=>''},
			'vid_box'=>{type=>'Gtk2::VBox',action=>'new',opts=>[0,0],wname=>''},
			'create_dvd_button'=>{type=>'Gtk2::Button',action=>'new',opts=>['Create DVD File System'],wname=>'dvd_file_system'},

			'snap'=>{type=>'Gtk2::ComboBox',action=>'new_text',opts=>[],wname=>''},
			'sec_label'=>{type=>'Gtk2::Label',action=>'new',opts=>['Seconds for Snapshot'],wname=>''},
			'sec'=>{type=>'Gtk2::Entry',action=>'new',opts=>[],wname=>'',width=>5},
			'dvd_size'=>{type=>'Gtk2::Label',action=>'new',opts=>[],wname=>''},
			'dvd_size_frame'=>{type=>'Gtk2::Frame',action=>'new',opts=>[],wname=>''},
			'layout_dvd'=>{type=>'Gtk2::Table',action=>'new',opts=>[9,9],wname=>''},
			dvd_table=>{type=>'Gtk2::Table',action=>'new',opts=>[1,1],wname=>''},
			file_name=>{type=>'Gtk2::Label',action=>'new',opts=>["File Name"],wname=>''},
			title_label=>{type=>'Gtk2::Label',action=>'new',opts=>['Title Number'],wname=>''},
			order_label=>{type=>'Gtk2::Label',action=>'new',opts=>["Position"],wname=>''},
			file_name_frame=>{type=>'Gtk2::Frame',action=>'new',opts=>[],wname=>''},
			title_label_frame=>{type=>'Gtk2::Frame',action=>'new',opts=>[],wname=>''},
			order_label_frame=>{type=>'Gtk2::Frame',action=>'new',opts=>[],wname=>''},
			files_frame=>{type=>'Gtk2::Frame',action=>'new',opts=>[],wname=>''},
			'run_box'=>{type=>'Gtk2::VBox',action=>'new',opts=>[0,0],wname=>''}

			);
		my %widgetd=%{&create_widgets(\%widgets_dvd)};
		my %opts;
		foreach my $keys (keys %widgetd){
		$opts{$keys}=$widgetd{$keys}
		}
		$opts{sel_opts_vbox}=$widget{sel_opts_vbox};
		$opts{btn_open}=$widget{btn_open};
		
		$widgetd{dvd_table}->hide;
		my $label_text="Update Title Descriptions for DVD";
		my @chaps=(2,5,7,10,15,20,25,30);
			foreach my $chaps (@chaps){
				$widgetd{chap_length}->append_text($chaps)
				}
		$widgetd{chap_length}->set_active(1);

		my $dir=$ENV{'HOME'};
		my $default="$dir/menu_dvd.jpeg";
			if (!(-e $default)){
			my $prefix1=$prefix;
			$prefix1=~s/bin\/burn_360//;
			}
		$widgetd{home_menu}->set_text($default);
		$widgetd{home_menu_chg}->signal_connect('clicked' ,  sub{
							$widgetd{home_menu}->set_text(&selection_menu_jpeg($widgetd{home_menu}))
							}
							);
		my %files1;

no strict 'refs';
			if ($subname->[1] eq 'dvd_setup' or $subname->[1] eq 'dvd_modify'){
			my $sub;
				&pack_widgets($opts{vid_box},[$opts{files_frame}],[1,0,3]);
				&pack_widgets($widget{sel_opts_vbox},{1=>[$widgetd{layout_dvd},0,0,0],2=>[$opts{vid_box},0,0,0],3=>[$opts{run_box},0,0,0]});
		$opts{files_frame}->add($widgetd{dvd_table});
			foreach my $f (qw /$widgetd{file_name_frame} $widgetd{title_label_frame} $widgetd{order_label_frame} $widgetd{dvd_size_frame}/){
				my $frame=eval ($f);
				my $w=$f;
				$w=~s/_frame//;
				my $widget=eval($w);
				$frame->add($widget);
				}
				$sub = 'dvd_setup';
				foreach my $text ('Choose Type of Title','Titles as Text','Titles as Video'){
						$widgetd{snap}->append_text($text);
						}

				$widgetd{snap}->set_active(0);
				my $sep=Gtk2::HSeparator->new;
				$widgetd{sec}->set_text(15);
				if ($subname->[1] eq 'dvd_modify'){

					foreach my $keys (keys %files){
							if ($files{$keys}->[0] eq 'dvd_setup' ) {
							no strict 'refs';
							delete $files{$keys}
							}
						}
					my $count_key=scalar keys %files;

					my %files1=&dvd_modify;

						foreach my $keys (keys %files1){
						$count_key++;										
						$files{$count_key}=[@{$files1{$keys}}]
						}

					}
$widgetd{layout_dvd}->set_col_spacing(2,100);
		$widgetd{layout_dvd}->attach($widget{btn_open},0,2,0,2,['shrink','fill'],'shrink',0,0);
		$widgetd{layout_dvd}->attach($widgetd{dvd_titles_btn},0,2,2,3,'shrink','shrink',0,0);
		$widgetd{layout_dvd}->attach($widgetd{prev_cmd},0,2,3,4,'shrink','shrink',0,0);
		$widgetd{layout_dvd}->attach($widgetd{chap_length_label},3,4,7,8,'shrink','shrink',0,0);
		$widgetd{layout_dvd}->attach($widgetd{chap_length},5,6,7,8,'shrink','shrink',0,0);
		$widgetd{layout_dvd}->attach($widgetd{cd_work_label},0,1,7,8,'shrink','shrink',0,0);
		$widgetd{layout_dvd}->attach($widgetd{cd_work_btn},1,2,7,8,'shrink','shrink',0,0);
		$widgetd{layout_dvd}->attach($widgetd{dvd_title_lable},3,6,0,1,'shrink','shrink',0,0);
		$widgetd{layout_dvd}->attach($widgetd{dvd_title},3,6,1,2,['shrink','fill'],'shrink',0,0);
		$widgetd{layout_dvd}->attach($widgetd{home_menu_label},3,6,2,3,'shrink','shrink',1,0);
		$widgetd{layout_dvd}->attach($widgetd{home_menu},3,6,3,4,['shrink','fill'],'shrink',1,0);
		$widgetd{layout_dvd}->attach($widgetd{home_menu_chg},3,6,4,5,['shrink','fill'],'shrink',1,0);
		$widgetd{layout_dvd}->attach($widgetd{sec_label},4,5,5,6,'shrink','shrink',1,0);
		$widgetd{layout_dvd}->attach($widgetd{sec},5,6,5,6,['shrink','fill'],'shrink',5,0);
		$widgetd{layout_dvd}->attach($widgetd{snap},3,4,5,6,'shrink','shrink',0,0);
		$widgetd{layout_dvd}->attach($widget{delay_hbox},0,2,5,6,['shrink','fill'],'shrink',0,0);
		$widgetd{layout_dvd}->attach($widgetd{dvd_size_frame},6,7,0,1,['shrink','fill'],'shrink',0,0);

		$widgetd{dvd_table}->attach($widgetd{file_name_frame},0,1,0,1,['shrink','fill'],['shrink','fill'],0,0);
		$widgetd{dvd_table}->attach($widgetd{title_label_frame},1,2,0,1,['shrink','fill'],['shrink','fill'],0,0);
		$widgetd{dvd_table}->attach($widgetd{order_label_frame},2,3,0,1,['shrink','fill'],['shrink','fill'],0,0);
		$widgetd{dvd_table}->set_col_spacing(2,100);
		&dvd_refresh(\%opts) ;
		no strict 'refs'; 
		$opts{home_menu}=$widgetd{home_menu}->get_text;

		$widget{btn_open}->signal_connect('clicked',sub{
					&selection('Add Movie to DVD','open',$widget{sel_opts_vbox},'dvd_setup');
					&dvd_refresh(\%opts);
					}
					);
		$widgetd{dvd_titles_btn}->signal_connect('clicked'=>sub{
									no strict 'refs'; &$sub(\%opts)
									}
									);
		$widgetd{files_frame}->hide;
		}
		else {

&{$subname->[1]}(\%opts)
}
	}

	elsif ($subname->[0] eq 'capture') {
	our $device;
	my $media;
	my $prog;
	my $opts;
	our $track;
	my $sel_cap_vbox=Gtk2::VBox->new(0,1);
	my $sel_cap_hbox=Gtk2::HBox->new(0,1);
	my $dir=&dir_sel;
	my $source;
	my $capture_options;
	$sel_cap_hbox->set_name('cap_hbox');
	$sel_cap_vbox->set_name('cap_vbox');
	$sel_cap_vbox->pack_start($sel_cap_hbox,1,1,0);
	$widget{sel_opts_hbox}->pack_start($sel_cap_vbox,1,1,0);
	&source_search($subname,$sel_cap_hbox,$sel_cap_vbox,$widget{sel_opts_vbox},$widget{delay});
	}

	if ($subname->[0]!~/DVD/){
	$widget{sel_opts_vbox}->pack_start($widget{sel_opts_hbox},0,0,0) ;
	$widget{btn_open}->signal_connect('clicked' ,  sub{&selection('Open file','open',$widget{sel_opts_vbox},$subname->[1],undef,$widget{video_type})});
	}
#}
$widget{btn_open}->drag_dest_set(["drop","motion","highlight"],
                         ["copy","private","default","move","link","ask"]);
$widget{btn_open}->signal_connect(drag_data_received => \&drop_handler);
  
	  my $target_list = Gtk2::TargetList->new();
	  my $atom = Gtk2::Gdk::Atom->new("text/uri-list");
	  $target_list->add($atom, 0, 0);
	use URI::Escape;
	  $widget{btn_open}->drag_dest_set_target_list($target_list);
	  
		  sub drop_handler {
		    my ($treeview, $context, $widget_x, $widget_y, $data, $info, $time) = @_;
		my $uris= $data->data;
		$uris=~s/\n//g;
		my @uris=split /\r/,$uris;
		my @file;
		    foreach my $uri (@uris) {
		$uri=~s/file:\/\///;
		my $file=uri_unescape($uri);
		chomp $file;$uri=~s/\n|\r//g;
		push @file,$file;
		    }
	&selection('Open file','open',$widget{sel_opts_vbox},$subname->[1],\@file,$widget{video_type})
	  }

$widget{sel_opts_frame}->add($widget{sel_opts_vbox});
$prog_vbox->pack_start($widget{sel_opts_frame},1,1,0) ;
push @{$modules{$subname}},[$widget{sel_opts_frame}];
$widget{sel_opts_frame}->show;
$widget{sel_opts_vbox}->show_all;
return
}

## File Operations ##

sub selection {
%options=&options_get;
my ($heading,$type,$sel_opts_vbox,$subname,$file,$video_type) = @_;
my @filenames;
my $key;
	unless ($file){
		my ($filter,$filterall,$filterdvd,$dir_label);
		my $file_chooser =Gtk2::FileChooserDialog->new (
		$heading,undef,$type,'gtk-cancel' => 'cancel','gtk-ok' => 'ok'
		);

			if (exists $modules{'dvd_modify'}){
			$dvd_combo->append_text('');
			$dvd_combo->set_active(5);
			$dvd_combo->remove_text(5);
			}
		$file_chooser->set_select_multiple('TRUE') if $subname ne 'dvd_burn';
		$file_chooser->set_current_folder($options{'dir'});
		$filter=Gtk2::FileFilter->new();
		$filterall=Gtk2::FileFilter->new();
		$filterdvd=Gtk2::FileFilter->new();
		$filter->set_name("Movies") ;
		$filterdvd->set_name("DVD XML files") ;
		$filterall->set_name("All Files") ;
		my %types=(
		encode=>[["video/mpeg","video/x-msvideo","video/x-divx","video/x-xvid","video/x-ms-asf","image/*","audio/*","application/ogg","application/x-extension-vob","application/x-flash-video","application/octet-stream"],['add_mime_type']],
		dvd_setup=>[['*.vob'],['add_pattern']],
		create_image=>[["video/mpeg"],['add_mime_type']],
		xml=>['dvd*.xml']
		);
		no strict 'refs';

			unless ($heading=~/xml/){
				foreach my $mimes (@{$types{$subname}->[0]}){
my $action=$types{$subname}->[1][0];

					$filter->$action($mimes);
					}
				(defined $filter)&&($file_chooser->add_filter($filter)) ;
				}

			else {
				foreach my $mimes (@{types{$heading}->[0]}){
					$filterdvd->add_pattern($mimes);
					}

					(defined $filterdvd)&&($file_chooser->add_filter($filterdvd)) ;
				}
		
		$filterall->add_pattern('*');

		if ($subname=~/^dvd_from/){
		(defined $filterall)&&($file_chooser->add_filter($filterall)) ;
		}

		$file_chooser->add_filter($filterall);

		if ('ok' eq $file_chooser->run){
			@filenames = $file_chooser-> get_filenames
			};
		$file_chooser->destroy;
		}
	else {
		foreach my $file (@{$file}){
		push @filenames,$file ;
		}
		}
	my %actions_gui=(encode=>['encode_gui_add','$subname,$file_vbox2,$filename,undef,$video_type,$key',1],
	dvd_setup=>['dvd_gui','$subname,undef,$filename,undef,undef,1,undef,undef,undef',0],
	'dvd_from_image'=>['none','',0],
	'dvd_modify'=>['none','',0],
	'dvd_burn'=>['none','',0]
	);

	if ($type eq 'select-folder'){
		&dir_sel($filenames[0]);
		return 1;
		}
	$key=max ( keys %files);
	foreach my $filename (@filenames){
	$key++;
	my $chk='0';

		foreach my $keys (keys %files){
			if ($files{$keys}->[2] eq $filename and $files{$keys}->[0] eq $subname){
				$chk='1' 
				}
				}
		no strict 'refs';
		if ($chk eq '0'){
		my @sub_vars=$actions_gui{$subname}->[0]->($sel_opts_vbox,$subname,$filename,$video_type,$key);
		push (@{$files{$key}},@sub_vars);
		$files{$key}->[3]{pids}='' ;
		}
		}
return $filenames[0];# if $actions{$subname}->[1] == 0;
1
}

sub none {}

sub dvd_refresh {
my ($opts)=@_;
my $previewc=$opts->{prev_cmd}->get_text;

my %widgets=(
video_track=>{type=>'Gtk2::ComboBox',action=>'new_text',opts=>[],wname=>''},
order=>{type=>'Gtk2::ComboBox',action=>'new_text',opts=>[],wname=>''},

file_frame=>{type=>'Gtk2::Frame',action=>'new',opts=>[],wname=>''},
btn_remove=>{type=>'Gtk2::Button',action=>'new',opts=>["Remove"],wname=>''},

file_label=>{type=>'Gtk2::Label',action=>'new',opts=>[],wname=>''}
);
&dvd_size('dvd_setup',$$opts{dvd_size},$opts->{cd_work_btn});
my %extra;
foreach my $r ($$opts{dvd_table}->get_children){
my $t=$$opts{dvd_table}->child_get_property($r,'top-attach');
$$opts{dvd_table}->remove($r) if $t!=0;
}
$opts->{cd_work_btn}->signal_connect('clicked'=>sub{
&dvd_size('dvd_setup',$$opts{dvd_size},$opts->{cd_work_btn});
}
);
my %order;
use File::Basename;
my $count=1;

	foreach my $order (sort {$files{$a}->[3]{title} <=> $files{$b}->[3]{title}||$files{$a}->[3]{order} <=> $files{$b}->[3]{order}||uc(basename($files{$a}->[2])) cmp uc(basename($files{$b}->[2]))} keys %files){
my $preview=Gtk2::Button->new('Preview');
	if ($files{$order}->[0] eq 'dvd_setup'){
			my %widget=%{&create_widgets(\%widgets)};
		if ($files{$order}->[3]{exist}!=1){
			$files{$order}->[3]={title=>$count,order=>$count,title_name=>''} if $files{$order}->[3]{exist}!=2;
			$files{$order}->[3]{exist}=1;
			}
			my $file_name=$files{$order}->[2];
			$widget{file_label}->set_text(&word_wrap($file_name,50));
			$widget{file_label}->set_alignment(0,0);
			$widget{file_frame}->add($widget{file_label});
			$$opts{dvd_table}->attach($widget{file_frame},0,1,$count,$count+1,['shrink','fill'],['shrink','fill'],0,0);
			$$opts{dvd_table}->attach($widget{video_track},1,2,$count,$count+1,['shrink','fill'],['shrink','fill'],0,0);
			$$opts{dvd_table}->attach($widget{order},2,3,$count,$count+1,['shrink','fill'],['shrink','fill'],0,0);
			$$opts{dvd_table}->attach($widget{btn_remove},3,4,$count,$count+1,['shrink','fill'],['shrink','fill'],0,0);
			$$opts{dvd_table}->attach($preview,4,5,$count,$count+1,['shrink','fill'],['shrink','fill'],0,0);
$preview->signal_connect('clicked'=>sub{system "$previewc \'$file_name\'"});
$count++;


			my @tracks=(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15);
				foreach my $tracks (@tracks){
				$widget{video_track}->append_text($tracks);# unless $tracks>8;
				$widget{order}->append_text($tracks)
				}
			$files{$order}->[3]{chapterw}=$widget{order};
			$widget{video_track}->set_active($files{$order}->[3]{title}-1);
			$widget{order}->set_active($files{$order}->[3]{order}-1);

			$widget{video_track}->signal_connect('changed',sub{
									$files{$order}->[3]{title}=$widget{video_track}->get_active_text;
					my $title_chap=1;
					my $count_chap=1;
					foreach my $file (sort {$files{$a}->[3]{title}<=>$files{$b}->[3]{title}||$files{$a}->[2] cmp $files{$b}->[2]||$a<=>$b} keys %files){
					if ($files{$file}->[3]{title} != $title_chap){
					$count_chap=1
					}

					$files{$file}->[3]{order}=$count_chap;
					$title_chap=$files{$file}->[3]{title};
					$files{$file}->[3]{chapterw}->set_active($files{$file}->[3]{order}-1);
					$count_chap++;
					}
					}
									);
			$widget{btn_remove}->signal_connect('clicked' => sub{
						remove_file($files{$order}->[2],$$opts{sel_opts_vbox},undef,'dvd_setup');
						my $row=$$opts{dvd_table}->child_get_property($widget{btn_remove},'top-attach');
						foreach my $w ($widget{file_frame},$widget{video_track},$widget{order},$widget{btn_remove},$preview){
						my $t=$$opts{dvd_table}->child_get_property($w,'top-attach');				
						$w->destroy if $t==$row;
						}

&dvd_size('dvd_setup',$$opts{dvd_size},$opts->{cd_work_btn});
								}
								);
			$widget{order}->signal_connect('changed',sub{
							$files{$order}->[3]{order}=$widget{order}->get_active_text
							}
							);

		}



	}
sub flash_label {
#thanks to muppet on gtk-perl list#
	my ($widget,$cd_opt) = @_;
	my $plainstyle = $widget->get_modifier_style->copy;
	$widget->modify_fg ('normal', Gtk2::Gdk::Color->new (65535, 0, 0));
	my $onstyle = $widget->get_modifier_style;

	my $wax = 'on';
	Glib::Timeout->add (500, sub {
		if ($wax eq 'on') {
			$widget->modify_style ($plainstyle);
			$wax = 'off';
		} else {
			$widget->modify_style ($onstyle);
			$wax = 'on';
		}
		return 1;
	});
}

$$opts{dvd_table}->show_all;
}
	sub dvd_size {
	my ($subname,$label,$cd_opt)=@_;
	if ($subname=~/dvd_setup/){
		my $sum;
		foreach my $key (keys %files){
			my $s= -s $files{$key}->[2],"\n";
			$sum += $s;
			}
		$sum=int($sum/(1024*1024));
		$label->set_text("DVD Size\n$sum");
		my $max;
		if($cd_opt->get_active eq 1){
			$max=685
			}
		else{
			$max=4400
			};

		if ($sum > $max){
		&flash_label($label,$cd_opt)
		}


		}
	}


sub dvd_gui {
my ($sel_opts_vbox,$subname,$filename)=@_;
return $subname,undef,$filename,,undef,undef,'1'
}

sub dvd_image_gui {
my ($sel_opts_vbox,$subname,$filename)=@_;

my $file_vbox2=Gtk2::VBox->new(0,0);
my $file_hbox = Gtk2::HBox->new(0,1);
my $fc_file_frame=Gtk2::Frame->new();
my $file=Gtk2::Label->new($filename);
$file->set_alignment(0,0);
$file_vbox2->pack_start($file,0,0,0);
$fc_file_frame->add($file_vbox2);
$sel_opts_vbox->pack_start($fc_file_frame,0,0,0) ;
return $subname,$file_vbox2,$filename
}


sub encode_gui_add {
my ($sel_opts_vbox,$subname,$filename,$video_type,$file_id)=@_;

my %widgets=(
file_vbox2=>{type=>'Gtk2::VBox',action=>'new',opts=>[0,0],wname=>'filevbox2'},
file_hbox=>{type=>'Gtk2::HBox',action=>'new',opts=>[0,0],wname=>'file_hbox'},
fc_label_frame=>{type=>'Gtk2::Frame',action=>'new',opts=>[],wname=>'fc_label_frame'},
fc_file_frame=>{type=>'Gtk2::Frame',action=>'new',opts=>[],wname=>'fc_file_frame'},
fc_label=>{type=>'Gtk2::Label',action=>'new',opts=>[],wname=>'fc_label'},
file_start=>{type=>'Gtk2::ComboBoxEntry',action=>'new_text',opts=>[],wname=>'fc_file_frame'},
file_time=>{type=>'Gtk2::ComboBoxEntry',action=>'new_text',opts=>[],wname=>'layout_entry'},
file_start_label=>{type=>'Gtk2::Label',action=>'new',opts=>['start'],wname=>'fc_label'},
file_time_label=>{type=>'Gtk2::Label',action=>'new',opts=>['Time'],wname=>'fc_label_col'},
video_track=>{type=>'Gtk2::ComboBox',action=>'new_text',opts=>[],wname=>'fc_label_frame'},
audio_track=>{type=>'Gtk2::ComboBoxEntry',action=>'new_text',opts=>[],wname=>'fc_file_frame'},
quality=>{type=>'Gtk2::ComboBoxEntry',action=>'new_text',opts=>[],wname=>'layout_entry'},
sync=>{type=>'Gtk2::ComboBoxEntry',action=>'new_text',opts=>[],wname=>'layout_entry'},
video_track_label=>{type=>'Gtk2::Label',action=>'new',opts=>["Video\nTrack"],wname=>'fc_label_frame'},
audio_track_label=>{type=>'Gtk2::Label',action=>'new',opts=>["Audio\nTrack"],wname=>'fc_file_frame'},
quality_label=>{type=>'Gtk2::Label',action=>'new',opts=>["Quality\n"],wname=>'layout_entry'},
sync_label=>{type=>'Gtk2::Label',action=>'new',opts=>["Fix sync (in seconds -\nminus to delay audio)"],wname=>'layout_entry'},
aspect_frame=>{type=>'Gtk2::Frame',action=>'new',opts=>[],wname=>''},
aspect_label=>{type=>'Gtk2::Label',action=>'new',opts=>["Adjust Aspect\nHeight percent"],wname=>'aspect_label'},
aspect_box=>{type=>'Gtk2::ComboBoxEntry',action=>'new_text',opts=>[],wname=>'aspect_box'},
artist_label=>{type=>'Gtk2::Label',action=>'new',opts=>["Artist"],wname=>'Artist_Label'},
title_label=>{type=>'Gtk2::Label',action=>'new',opts=>["Title"],wname=>'Title_label'},
album_label=>{type=>'Gtk2::Label',action=>'new',opts=>["Album"],wname=>"Album_label"},
year_label=>{type=>'Gtk2::Label',action=>'new',opts=>["Date"],wname=>"Date_Label"},
genre_label=>{type=>'Gtk2::Label',action=>'new',opts=>["Genre"],wname=>"Genre_Label"},
track_label=>{type=>'Gtk2::Label',action=>'new',opts=>["Track No"],wname=>"Track_Label"},
cddb_label=>{type=>'Gtk2::Label',action=>'new',opts=>["CDDB ID"],wname=>"CDDB_ID_Label"},
mb_label=>{type=>'Gtk2::Label',action=>'new',opts=>["MusicBrainz_ID"],wname=>"MusicBrainz_ID_Label"},
artist=>{type=>'Gtk2::Entry',action=>'new',opts=>[],wname=>'artist'},
title=>{type=>'Gtk2::Entry',action=>'new',opts=>[],wname=>'title'},
album=>{type=>'Gtk2::Entry',action=>'new',opts=>[],wname=>'album'},
year=>{type=>'Gtk2::Entry',action=>'new',opts=>[],wname=>'year'},
genre=>{type=>'Gtk2::Entry',action=>'new',opts=>[],wname=>'genre'},
track=>{type=>'Gtk2::Entry',action=>'new',opts=>[],wname=>'track'},
cddb=>{type=>'Gtk2::Entry',action=>'new',opts=>[],wname=>'cddb'},
mb=>{type=>'Gtk2::Entry',action=>'new',opts=>[],wname=>'mb'},
vid_frame=>{type=>'Gtk2::Frame',action=>'new',opts=>[],wname=>'vid_frame'},
aud_frame=>{type=>'Gtk2::Frame',action=>'new',opts=>[],wname=>'aud_frame'},
sync_frame=>{type=>'Gtk2::Frame',action=>'new',opts=>[],wname=>'sync_frame'},
qual_frame=>{type=>'Gtk2::Frame',action=>'new',opts=>[],wname=>'qual_frame'},
fc_btn=>{type=>'Gtk2::Button',action=>'new',opts=>["\nRemove\n"],wname=>'remove_button'},
cancel_vbox=>{type=>'Gtk2::VBox',action=>'new',opts=>[0,0],wname=>'cancel_vbox'},
layout_table=>{type=>'Gtk2::Table',action=>'new',opts=>[2,10,0],wname=>''},
layout_music=>{type=>'Gtk2::Table',action=>'new',opts=>[7,3,0],wname=>''},
run_box=>{type=>'Gtk2::VBox',action=>'new',opts=>[0.0],wname=>''}
);

my %widget=%{&create_widgets(\%widgets)};
my $fc_file=&word_wrap($filename,'80');
$widget{fc_label}->set_text($fc_file);
$widget{fc_label}->set_selectable(1);
$widget{fc_label}->set_alignment(0,1);



my @times_sel=("00:30:00","01:00:00","01:30:00","02:00:00","02:30:00","03:00:00","03:30:00","04:00:00","04:30:00","05:00:00");

	foreach my $times (@times_sel){
	$widget{file_start}->append_text($times);
	$widget{file_time}->append_text($times);
	}
my @sync=("-50","-40","-30","-20","-10","0","10","20","30","40","50");

	foreach my $synct (@sync){
		$widget{sync}->append_text($synct)
		}
	foreach my $aspect ('-20','-15','-10','-5','5','10','15','20'){
		$widget{aspect_box}->append_text($aspect)
		}

my %pack_frame=(
		1=>[$widget{vid_frame},$widget{video_track_label}],
		2=>[$widget{aud_frame},$widget{audio_track_label}],
		3=>[$widget{qual_frame},$widget{quality_label}],
		4=>[$widget{sync_frame},$widget{sync_label}],
		5=>[$widget{aspect_frame},$widget{aspect_label}]
		);

			foreach my $keys (keys %pack_frame){
			no strict 'refs';
			${$pack_frame{$keys}}[0]->add(${$pack_frame{$keys}}[1])
			}

my @tracks=('',0,1,2,3,4,5,6,7,8,9);
#	$widget{quality}->append_text($tracks);

	foreach my $tracks (@tracks){
	$widget{video_track}->append_text($tracks);
	$widget{audio_track}->append_text($tracks);
	}

	foreach my $e ($widget{artist},$widget{title},$widget{album},$widget{year},$widget{genre},$widget{track},$widget{cddb},$widget{mb}){
	$e->set_width_chars(40)
	}
$widget{fc_btn}->signal_connect('clicked'=>sub{no strict 'refs';&remove_file($filename,$sel_opts_vbox,$widget{fc_file_frame},$subname)});
$widget{fc_label_frame}->add($widget{fc_label});
$widget{file_vbox2}->pack_start($widget{fc_label_frame},0,0,0);

$widget{file_hbox}->pack_start($widget{layout_table},0,0,3);
$widget{file_hbox}->pack_start($widget{layout_music},0,0,3);
$widget{file_hbox}->pack_end($widget{fc_btn},0,0,0);
&pack_widgets($widget{file_vbox2},{1=>[$widget{file_hbox},0,0,3],2=>[$widget{run_box},0,0,0]});
$widget{fc_file_frame}->add($widget{file_vbox2});
$sel_opts_vbox->pack_start($widget{fc_file_frame},1,1,2) ;

my @table_opts=('shrink','shrink',0,0);
my $rect= $widget{sync_label}->size_request;
my $recta= $widget{audio_track}->size_request;
my $rect2=$widget{layout_table}->size_request;
$widget{sync}->set_size_request($rect->width + 4,-1);
$widget{audio_track}->set_size_request(60,-1);
$widget{quality}->set_size_request($widget{quality_label}->size_request->width + 4,-1);
$widget{aspect_box}->set_size_request($widget{aspect_label}->size_request->width + 4,-1);
#$widget{layout_table}->set_col_spacing(5,100);
$widget{layout_table}->attach($widget{file_start_label},0,1,1,2,@table_opts);
$widget{layout_table}->attach($widget{file_start},1,2,1,2,@table_opts);
$widget{layout_table}->attach($widget{file_time_label},0,1,2,3,@table_opts);
$widget{layout_table}->attach($widget{file_time},1,2,2,3,@table_opts);
$widget{layout_table}->attach($widget{vid_frame},2,3,1,2,@table_opts);
$widget{layout_table}->attach($widget{video_track},2,3,2,3,@table_opts);
$widget{layout_table}->attach($widget{aud_frame},3,4,1,2,@table_opts);
$widget{layout_table}->attach($widget{audio_track},3,4,2,3,@table_opts);
$widget{layout_table}->attach($widget{sync_frame},4,5,1,2,'shrink','shrink',0,0);
$widget{layout_table}->attach($widget{sync},4,5,2,3,@table_opts);
$widget{layout_table}->attach($widget{qual_frame},5,6,1,2,@table_opts);
$widget{layout_table}->attach($widget{quality},5,6,2,3,@table_opts);
$widget{layout_table}->attach($widget{aspect_frame},6,7,1,2,@table_opts);
$widget{layout_table}->attach($widget{aspect_box},6,7,2,3,@table_opts);

	my $title_app=basename($filename);
$title_app=~s/\*/\\*/g;
	$second_title=~s/$title_app//;
	$second_title=$second_title.'/'.$title_app;
	$second_title=~s/^\///;
	$window->set_title("Burn 360 - ".$second_title);

my $w_cnt=0;
foreach my $w ($widget{artist_label},$widget{title_label},$widget{album_label},$widget{year_label},$widget{genre_label},$widget{track_label}){
$w->set_justify('left');
$widget{layout_music}->attach($w,0,1,$w_cnt,$w_cnt+1,@table_opts);
$w_cnt++
}
my $w_cnt=0;
foreach my $w ($widget{artist},$widget{title},$widget{album},$widget{year},$widget{genre},$widget{track}){
$widget{layout_music}->attach($w,1,2,$w_cnt,$w_cnt+1,@table_opts);
$w_cnt++
}
	my %gui_hash;
		foreach my $w (keys %widget){
			$gui_hash{$w}=$widget{$w} ;
			}
$widget{fc_file_frame}->show_all;
my $active_type=$video_type->get_active_text;

&type_encode(\%gui_hash,$active_type,$filename);
&get_track_name(\%gui_hash,$active_type,$filename);

return $subname,$widget{file_vbox2},$filename,\%gui_hash

}

sub qual_type {
my ($vtype,$qual)=@_

}
sub dir_sel {

my $dir=shift;
my $color1='blue';
	if (-e $dir) {
	$options{'dir'}=$dir;
	$color1='red';
$dbh->do("UPDATE config set value='$dir' where option='dir'");
$options{'dir'}=$dir;
	}

no strict 'refs';
my $dirww=&word_wrap($options{'dir'},'20');
$dir_save_label->set_markup("<span color= \"$color1\" >$dirww </span>");

return \$dir1;
}

sub remove_file {
my ($file,$sel_opts_vbox,$fc_file_frame,$subname)=@_;
my $key;
no strict 'refs';
	foreach my $keys (keys %files){
	$key = $keys if $file eq $files{$keys}->[2] and $files{$keys}->[0] eq $subname;
	}
kill 15,@{$files{$key}[3]->{pids}} if defined($files{$key}[3]->{pids});
$second_title=$window->get_title;
my $filename=basename($files{$key}->[2]);
$second_title=~s/\/$filename//;
$second_title=~s/Burn 360 - //;
$window->set_title("Burn 360 - $second_title");
delete $files{$key};
$fc_file_frame->destroy if defined($fc_file_frame);
}

## Action Subs - What we are doing to files etc ##
sub type_encode {
my ($f,$type,$file_id)=@_;
my %hash=%{$f};
my $type_g;
my $ext;
foreach my $key (sort {$a<=>$b} keys %options){

no strict 'refs';

my $chk=$options{$key}->{vtype};

if ($type=~/$chk/){
$ext=$options{$key}->{ext},"\n";
$type_g=$options{$key}->{type};
};
}

if ($type=~/^Select/){
$type_g=$type
}

my %widgets=(Video=>['layout_table','layout_music'],
	'Select Encoding Type'=>['layout_table','layout_music'],
#		'DVD Music'=>['layout_music','layout_table'],
		'Audio'=>['layout_music','layout_table'],
		);
no strict 'refs';

my @qual;
if ($ext=~/mp4/i){
@qual=(18,19,20,21,22,23,24,35,26,27,28,29,30,31,32)
}
else {
@qual=(2,3,4,5,6,7,8,9)
}

$hash{quality}->get_model->clear;
foreach my $qual (@qual){
$hash{quality}->append_text($qual)
}
$hash{$widgets{$type_g}->[0]}->show;
$hash{$widgets{$type_g}->[1]}->hide;
return $type_g;
}


sub encode {
my ($video_type,$vbox2,$sel_opts_vbox,$delay)=@_;
my $encode_type=$video_type->get_active();
my $enc='enc-act';
my $btn_encode = Gtk2::Button->new_from_stock('encode');
$btn_encode->set_relief('half');
$btn_encode->set_name('encode');
our $opts;
our $prog;
our $ext;
no strict 'refs';
my $run=0;
my $type_g;
#	foreach my $enc (keys %options){
#
#		if ($video_type->get_active_text eq $options{$enc}->{vtype}){
#			$opts=$options{$enc}->{opt};
#			$prog=$options{$enc}->{prog};
#			$ext=$options{$enc}->{ext};

#			}
#		}
	foreach my $f (keys %files){
		if ($files{$f}->[0] eq 'encode'){
		my %hash=%{$files{$f}[3]};
		my $filename=$files{$f}[2];
		$type_g= &type_encode(\%hash,$video_type->get_active_text,$filename);
		
			if ($type_g=~/Audio/){
			&get_track_name(\%hash,undef,$filename);
			}
		}
		}
$btn_encode->signal_connect('clicked' ,  sub{
my $dvb=$video_type->get_active_text;
	foreach my $enc (keys %options){

		if ($video_type->get_active_text eq $options{$enc}->{vtype}){
			$opts=$options{$enc}->{opt};
			$prog=$options{$enc}->{prog};
			$ext=$options{$enc}->{ext};

			}
		}
$sub_stop=0;
my $cancel_flag=0;
my $delay_flag=&delay_prog('encode_loop',$delay,$cancel_flag,$opts,$prog,$ext,$sel_opts_vbox,$delay,$dvb,$type_g);

}
);

my $butchk= \$vbox2->get_children ();
	if ((grep /Button/,$$butchk) eq 0){
		$vbox2->pack_start($btn_encode,1,1,0);
		}
		$btn_encode->show;
		}
sub delay_prog {
my @opts=@_;
my $timedel= $_[1]->get_text * 60;
my $timeout;
if ($timedel==0){
$timeout=1
}
else {
$timeout=30
}
my $cancel=$opts[2];
$opts[1]->signal_connect('changed'=>sub{
$cancel=1;
}
);

Glib::Timeout->add_seconds($timeout,sub{
$timedel-=$timeout if $timedel != 0;
if ($cancel==1) {return 0};
if ($timedel == 0){
no strict 'refs';
my $sub=$opts[0];
splice (@opts,0,3);
&$sub(@opts);
}


return $timedel
});
return
}

sub encode_loop {
my ($opts,$prog,$ext,$sel_opts_vbox,$delay,$dvb,$type_g)=@_;
my $subname='encode';
return 1 if $sub_stop==1;
foreach my $files1 (sort {$a<=>$b} keys %files){
my %actions;
#my $title_app=basename($files{$files1}->[2]);
#$second_title=~s/$title_app//;
#						$second_title=$second_title.'/'.basename($files{$files1}->[2]);
#						$second_title=~s/^\///;
#						$window->set_title("Burn 360 - ".$second_title);

$files{$files1}->[1]=$files{$files1}->[3]{run_box};
no strict 'refs';
	if (${$files{$files1}}[0] eq $subname){

	 {
	if ($dvb ne 'Fix DVB'){
		if ($type_g=~/Audio/){
		foreach my $w (qw /artist title track album genre year/){
			$actions{$w}=$files{$files1}->[3]{$w}->get_text
			}
		}
		if ($ext=~/mp3/){
		my @opts2;
		foreach my $key (keys %actions){
		push @opts2, ' -metadata '. uc($key).'="'.$actions{$key}.'"';
print $ext;		
}
		$opts=$opts.join '',@opts2;
		}

		if ($ext=~/ogg/){
		my $progrun=&run_cmd($files1,$opts,$prog,$ext,$subname,$sel_opts_vbox) ;
		my $prog2='vorbiscomment';
		my @opts2;

		foreach my $tag (keys %actions){
		push @opts2,' -t '.'"'.$tag.'='.$actions{$tag}.'"';
		}
		my ($file,$dir,$ext_o)=fileparse($files{$files1}[2],'.mp3','.ogg','.oga');
		$file=$file.$ext;

		my $opts2=' -w '.' '.join '',@opts2;
		my $out="\"$options{'dir'}/$file\"";
		my $cmd=$prog2.' '.$opts2.' '.$out;

		system ("$cmd");

		#my $progrun=&run_cmd(undef,$opts,$prog,$ext,$subname,$sel_opts_vbox) ;
		}
			if ($dvb eq 'DVD Music'){
				my $count;
				my %pos=(1=>[30,60,0],2=>[35,80,-5],3=>[40,100,-10],4=>[45,120,-15],5=>[50,140,-20],6=>[55,160,-25],7=>[60,180,-30],8=>[65,200,-35],9=>[70,220,-40],10=>[75,240,-45]);
				my $outdir=$options{'dir'}.'/dvd_tmp/';
				if (! -d $outdir){
					mkdir $outdir
					}
							$count=1;
								foreach my $key (sort {$a<=>$b} keys %pos){
my $stop=$sub_stop;
								for (1 .. 15) {

					
					my $widget=&gd_music($actions{artist},$actions{title},$sel_opts_vbox,$count,$pos{$key}->[0],$pos{$key}->[1],$pos{$key}->[2],$outdir,$files1);
					
					Gtk2->main_iteration while (Gtk2->events_pending);
					$count++

}
					}

					$files{$files1}->[3]{keep}=1;
					my $opts=" -loop_input -i $options{'dir'}/dvd_tmp/dvdjpeg%1d.png -qscale 2 -s 352x288 -target $broadcast{$options{broadcast}}->{target} -acodec mp2 -ar 48000 -ac 2 -ab 224k -shortest  -y " ;
					my $progrun=&run_cmd($files1,$opts,$prog,$ext,$subname,$sel_opts_vbox,undef,0) ;
			
					}

				else {
					my $progrun=&run_cmd($files1,$opts,$prog,$ext,$subname,$sel_opts_vbox,,0) if $dvb!~/ogg/ ;
					}
					$files{$files1}->[3]{keep}=2;
		}


	else {
	my $subname='fix';
	my $jar=$opts;

		if ($jar eq ''){
			$jar= join '',`find   /usr -name 'ProjectX.jar' 2>/dev/null`;
			chomp $jar;

			foreach my $opts (keys %options){
			@{$options{$opts}}[1] = $jar if @{$options{$opts}}[3] eq 'Fix DVB';
			}
			&save_options('jar');
		}

		my $out=$options{'dir'}.'/tmp/';
			unless (-e $out){
			system "mkdir $out";
			}
		my $prog=$prog." ".$jar.' -out '.$out." \"". ${$files{$files1}}[2].'"';

		my $progrun=&run_cmd($files1,$opts,$prog,$ext,$subname,$sel_opts_vbox) ;
		my $prog='ffmpeg -v 30 -async 24 -i ';
		use File::Basename;
		my ($file,$dir,$ext)=fileparse(${$files{$files1}}[2],'mpeg','mpg','ts');
		my $outfile= $out.$file.'mpeg';
		my $vid=$out.$file.'m2v';
		my $aud=$out.$file.'mp2';
		my $ext='mpeg';
		$files{$files1}->[3]{keep}=1;
		my $prog="$prog $vid -i $aud -acodec copy -vcodec copy -shortest -y \"$out$file$ext\"";
		my $progrun=&run_cmd($files1,$opts,$prog,$ext,$subname,$sel_opts_vbox,undef,'0') ;
		unlink $vid;
		unlink $aud;
		$files{$files1}->[3]{keep}=2;
		}

		}
}
}
}

sub get_track_name {
my  ($hash,$video_type,$file)=@_;
my $artist=$$hash{'artist'};
my $track=$$hash{'track'};
my $title=$$hash{'title'};
my $genre=$$hash{'genre'};
my $album=$$hash{'album'};
my $year=$$hash{'year'};
#my $track=$$hash{'track'};		


		my ($title1,$dir,$ext1)=fileparse($file,'.mp3','.ogg','.oga');
	if ($ext1=~/mp3|ogg|oga/){
		if ($artist->get_text eq '') {

				my %meta=&dvdaudio_parse($file,$ext1) ;
				$artist->set_text($meta{ARTIST});
				$title->set_text($meta{TITLE});
				$album->set_text($meta{ALBUM});
				$track->set_text($meta{TRACK});
				$genre->set_text($meta{GENRE});
				$year->set_text($meta{DATE});
		#		$title->set_text($meta{TITLE});
		#		$artist->set_text($meta{ARTIST});
		#		$title->set_text($meta{TITLE});
		}
	}
}

sub dvdaudio_parse {
my ($filename,$ext)=@_;
my ($title,$artist);
my @arr=`ffmpeg -i \"$filename\" 2>&1`;
my %meta;
	foreach my $line (@arr){
		chomp $line;
		if ($line=~/Metadata/ ... $line=~/Duration/){
			my @meta=split /:/,$line;
			$meta[0]=~s/\s+//g;
			$meta[1]=~s/^\s+//g;
			$meta{uc($meta[0])}=$meta[1] if $meta[0] !~/Duration|Metadata|atleast/i;
			}
		}
### This is taken verbatiom from id3v2.c in ffmpeg source ###
my %mp3_tag=   ( "TALB", "album",
     "TAL",  "album",
     "TCOM", "composer",
     "TCON", "genre",
     "TCO",  "genre",
     "TCOP", "copyright",
     "TDRL", "date",
     "TDRC", "date",
     "TENC", "encoded_by",
     "TEN",  "encoded_by",
     "TIT2", "title",
     "TT2",  "title",
     "TLAN", "language",
     "TPE1", "artist",
     "TP1",  "artist",
     "TPE2", "album_artist",
     "TP2",  "album_artist",
     "TPE3", "performer",
     "TP3",  "performer",
     "TPOS", "disc",
     "TPUB", "publisher",
     "TRCK", "track",
     "TRK",  "track",
     "TSOA", "album-sort",
     "TSOP", "artist-sort",
     "TSOT", "title-sort",
     "TSSE", "encoder"
);


	foreach my $keys (keys %meta){
		if ( exists $mp3_tag{$keys}){
			$meta{uc($mp3_tag{$keys})}=$meta{$keys};
			delete $meta{$keys};
			}
		}

($artist,$title)= ($meta{ARTIST},$meta{TITLE});  

	if ($title eq '' or $title =~/Unknown/i){
		my ($file,$dir,$ext)=fileparse($filename,'.ogg','.mp3');
		my @title=split /- /,$file;
		$title=$title[1];
		$title=~s/$ext$//;
		my @details= split /\//,$dir;
		my $cnt=(scalar @details) -2;
		$artist=$details[$cnt];
		$meta{ARTIST}=$artist;
		$meta{TITLE}=$title;
	}

return %meta;
}


sub gd_music {
my ($artist,$title,$sel_opts_vbox,$count,$title_x1,$title_y1,$ang,$outdir,$files1)=@_;
	my $frame=GD::Simple->new(352,288,1);
	my @rect_movie=(0,0,352,288);
		$frame->bgcolor('green');
		$frame->fgcolor('yellow');
		$frame->rectangle(@rect_movie);
		$frame->fgcolor('red');
		$frame->font("Verdana",24);
			my ($boundx,$boundy)= $frame->stringBounds($title);
			my $fontsize=int(270/$boundx*24);
		$frame->bgcolor(undef);
			my ($width,$height)=$frame->stringBounds($artist);
			my $mov=(352-$width)/2;
		$frame->moveTo($mov,$height);
		$frame->fgcolor('yellow');
		$frame->string($artist);
		$frame->fgcolor('red');
		$frame->moveTo($title_x1,$title_y1);
		$frame->angle($ang);
		$frame->fontsize($fontsize);
		$frame->string($title);

	my $frame_new=$outdir.'dvdjpeg'.$count.'.png';
	open (FRAME,">",$frame_new) or die print $!;
	print FRAME $frame->png;

my $append;
	if ($count==1){
	$append=0
	}
	else {
	$append=1
	}
my $widgetr;
my %widget;
no strict 'refs';
if ($append==0){
$widgetr=undef
}
else {
$widgetr=\%widget
}
%widget=%{&run_cmd($files1,undef,"$count ",undef,'gd_m',$sel_opts_vbox,undef,$append,$widgetr)};

return 1
}


sub opts {
my ($video_type,$enc)=@_;
	if (defined($video_type)){
		my $model= $video_type->get_model ;
		$model->clear ;

		my $title='Select Encoding Type';
		$video_type->append_text("$title");
		my @opts;

		no strict 'refs';
			foreach my $opt (sort {uc($options{$b}->{type}) cmp uc($options{$a}->{type})||uc($options{$a}->{vtype}) cmp uc($options{$b}->{vtype})} keys %options){
				$video_type->append_text($options{$opt}->{vtype}) if $opt ne 'dir' and $opt ne 'broadcast' ;
				}
		$video_type->set_active(0);
		}

}



## This is the programme that does the work ##
my $widget_reuse;

sub run_cmd {
my ($arr1,$opts,$prog,$ext,$subname,$run_hbox,$ext_opts,$append)=@_;
my $buffer;
my $encode1;
my %widget;
no strict 'refs';
	if ($append == 1){
	%widget=%{$widget_reuse};
	}
	else {

	$widget_reuse=''
	}


my %widgets=(
cmd_hbox=>{type=>'Gtk2::HBox',action=>'new',opts=>[0,0],wname=>''},
scroll=>{type=>'Gtk2::ScrolledWindow',action=>'new',opts=>[undef,undef],wname=>''}, 
textview=>{type=>'Gtk2::TextView',action=>'new',opts=>[],wname=>''}, 
cmd_vbox=>{type=>'Gtk2::VBox',action=>'new',opts=>[0,1],wname=>''}, 
gtkend=>{type=>'Gtk2::Entry',action=>'new',opts=>[],wname=>''}, 
log_frame=>{type=>'Gtk2::Frame',action=>'new',opts=>[],wname=>''}, 
shell_frame=>{type=>'Gtk2::Frame',action=>'new',opts=>[],wname=>''}, 
cancel_frame=>{type=>'Gtk2::Frame',action=>'new',opts=>[],wname=>''}, 
btn_cancel=>{type=>'Gtk2::Button',action=>'new_from_stock',opts=>['gtk-stop'],wname=>''}, 
output_label=>{type=>'Gtk2::Label',action=>'new',opts=>["Log"],wname=>''}, 
last_label=>{type=>'Gtk2::Label',action=>'new',opts=>["Shell Output"],wname=>''}, 
cancel_vbox=>{type=>'Gtk2::VBox',action=>'new',opts=>[0,0],wname=>''},
cmd_label_frame1=>{type=>'Gtk2::Frame',action=>'new',opts=>['Command Used'],wname=>''},
cmd_label=>{type=>'Gtk2::Label',action=>'new',opts=>[]}
);
	if ($append != 1){
		if (defined($files{$arr1}->[1])){
		unless ($files{$arr1}->[3]{keep}==1){
			foreach my $w ($files{$arr1}->[1]->get_children){
				$w->destroy
				};
		}
		}
#		}
		%widget=%{&create_widgets(\%widgets)} ;
		$widget{scroll}->add ($widget{textview});
		$widget{btn_cancel}->set_relief('half');
		$widget{cancel_frame}->add($widget{btn_cancel});

		$widget{log_frame}->add($widget{output_label});
		$widget{shell_frame}->add($widget{last_label});

		if ($sub_stop==0){
				&pack_widgets($widget{cmd_vbox},{1=>[$widget{log_frame},0,0,0],2=>[$widget{scroll},1,1,0],3=>[$widget{shell_frame},0,0,0]});
				&pack_widgets($widget{cmd_hbox},{1=>[$widget{cmd_vbox},1,1,0],2=>[$widget{cancel_vbox},0,0,0]}) ;
					$widget{cmd_vbox}->set_size_request(450,250) ;
					$widget{cmd_vbox}->pack_start($widget{gtkend},0,0,0) ;

					$widget{cancel_vbox}->pack_start($widget{cancel_frame},0,0,0) ;

				$widget{cmd_label_frame1}->add($widget{cmd_label});
				}
		}

		if ($subname !~/encode/ and $subname !~/fix/ and $subname !~/gd_m/){
		$run_hbox->pack_start($widget{cmd_hbox},1,1,0) if $append != 1;
		}
		else {
		${$files{$arr1}}[1]->pack_start($widget{cmd_hbox},1,1,5) if $append != 1;
		}


$widget{cmd_hbox}->show_all;
my @opts;
my %extras;
	if ($subname eq 'encode'){
	@opts=split /\s+/,$opts;


		if ($files{$arr1}->[3]){
		%extras=%{$files{$arr1}->[3]};
		}

		if ($extras{'file_start'}->get_active_text ne ''){
		push (@opts," -ss ".$extras{'file_start'}->get_active_text)
		}
		if ($extras{'file_time'}->get_active_text ne ''){
		push (@opts," -t ".$extras{'file_time'}->get_active_text)
		}
		if ($extras{'video_track'}->get_active_text ne ''){
		push (@opts," -map 0:".$extras{'video_track'}->get_active_text )
		}
		if ($extras{'audio_track'}->get_active_text ne ''){
			if ($extras{'video_track'}->get_active_text eq ''){
			push (@opts," -map 0.0 ")
			}
		push (@opts," -map 0:".$extras{'audio_track'}->get_active_text)
		}



		my $index='-1';
		if ($extras{'quality'}->get_active_text ne ''){
						my $qual;
							foreach my $main (@opts){
								$index++;
								if ($main eq '-qscale' or $main eq '-crf'){
									$qual='1';
									$opts[$index+1]=$extras{'quality'}->get_active_text;
									}
								}

#						push (@opts,"-qscale ".$extras{'quality'}->get_active_text) if $qual ne '1';
						}
		my $ffmpeg=&version;
			if ($ffmpeg > 8243){
				my $arr=-1;
					foreach my $opts1 (@opts){
					$arr++;
					my $len=length($opts[$arr+1]);
					$opts[$arr+1]="$opts[$arr+1]k" if substr($opts[$arr+1],$len) ne 'k' and $opts1 eq '-ab';
					}
					}
		}

	no strict 'refs';
	my ($inp,$dir);

	if ($subname!~/spumux/){
	($inp,$dir)=fileparse(${$files{$arr1}}[2]) if defined(${$files{$arr1}}[2]);
	}
	my $quote='"';
	my $save_dir=$options{'dir'};
	my @out;
	my $inp1;
	my $out1;

		if ($inp=~/\./){
		@out=split /\./,$inp if $subname ne 'dvd_burn';
		pop @out ;

		$out1=join('',@out);
		}
		else {$out1=$inp};

	if ($subname eq 'encode'){

		if ($extras{'sync'}->get_active_text ne ''){
				unshift (@opts,"-itsoffset ".$extras{'sync'}->get_active_text." -i $quote$dir$inp$quote");
				push (@opts,"-map 1:0 -map 0:1")
				}
		$opts=join(' ',@opts);
if ($extras{'aspect_box'}->get_active_text ne ''){
		my $adj=(100+ $extras{'aspect_box'}->get_active_text )/100;
		$opts=~s/dar\//dar*$adj\//                
		}
		}

my $file;
my $pid;
my %cmd=(
         'encode'=>"$prog $quote$dir$inp$quote $opts $quote$save_dir/$out1$ext$quote",
         'fix'=>"$prog  ",
         'capture'=>"$prog $opts",
         'dvd_setup'=>"$prog $opts ",
         'dvd_burn'=>"$prog $opts",
	'jpegs'=>"$prog",
	'spumux'=>"$prog",
        'gd'=>"$prog",
        'gd_m'=>"$prog"
);

die (main::encode_loop) if $sub_stop == 1;
die ("main::dvd_setup") if $sub_stop == 1;

my $pid1;
$pid=open($file, "-|","$cmd{$subname} 2>&1") or die $! if $subname !~/gd/ and $subname !~/gd_m/;
$pid1=$pid+1;

$widget{btn_cancel}->signal_connect('clicked', sub {
$sub_stop=1;

if ($pid1 != 1){
	kill (15,$pid1,$pid);
		if (kill($pid1,$pid) !=0){
					kill (9,$pid1,$pid);
					}
					}	
		}
	);

$widget{cmd_label}->set_selectable(1);
$widget{cmd_label}->set_alignment(0,0);
my $cmd_text=word_wrap($cmd{$subname},150);

$widget{cmd_label}->set_markup("<span background='yellow' foreground='red' size='small'><i>$cmd_text</i></span>");
$widget{cmd_label}->set_max_width_chars('90');
$widget{cmd_label_frame1}->set_size_request(20,70);
$files{$arr1}->[3]{pids}=[$pid1,$pid] if defined  ($files{$arr1}->[2]);

	foreach my $keys (keys %files){
	delete $files{$keys} if $keys <1;
	}
$widget{cmd_vbox}->pack_end($widget{cmd_label_frame1},0,0,0) if $append != 1;
$widget{cmd_vbox}->show_all if $append != 1;

$widget_reuse=\%widget;

	if ($subname ne 'gd' and $subname ne 'gd_m'){
		$buffer = $widget{textview}->get_buffer;
	our $tag=  Glib::IO->add_watch ( fileno($file), ['in', 'hup'], sub {
					my ($fileno, $condition,$tag) = @_;
					if ($condition eq 'hup') {
					close $file;
					Gtk2->main_quit();
					return 0;
					}

					my $line ;

					sysread $file, $line, 256;
					$buffer->insert($buffer->get_end_iter,$line) if $subname ne 'gd' and $subname ne 'gd_m';
					$widget{gtkend}->set_text($line);
					return 1;
					}
				);
				}
				else {
	$buffer = $widget{textview}->get_buffer;
	my $line;
		if ($cmd{'gd'} == 1 ){
		$line="Frames are being created for DVD Menu\n\nFrame $cmd{'gd'} has been created\n"
		}
		else {
		$line="Frame $cmd{'gd'} has been created\n";
		}
		if ($cmd{'gd_m'} == 1 ){
		$line="Frames are being created for Video\n\nFrame $cmd{'gd'} has been created\n"
		}
		else {
		$line="Frame $cmd{'gd_m'} has been created\n";
		}

		$buffer->insert($buffer->get_end_iter, $line);
		$widget{gtkend}->set_text($line);

return 1
}
;
		
Gtk2->main();


return 1
}

# Utility Functions
sub version {
my $version=`ffmpeg -version 2>&1`;
my $ffmpeg= substr((split /,/, $version)[0],index((split /,/,$version)[0],"SVN-r")+5);
}

sub word_wrap {
my ($string,$wrap)=@_;
my @wwl;
my $count=0;
my $string1=$string;
my $str_length=length($string1);

while ($count < $str_length){

{
my $len2;
my $line1=substr($string1,$count,$wrap);
if ((length($line1)+$count)<$str_length){
if (rindex($line1,' ') ne -1){
$len2=rindex($line1,' ');
}
else {$len2=$wrap}
}
else {$len2=$wrap}
my $strin2=substr($string1,$count,$len2);
push (@wwl,$strin2);
$count=$count+$len2;

}


}

$string=join("\n",@wwl);
return $string
}



# DVD Creation

sub selection_menu_jpeg {
my ($filename) = shift;
my ($filter);

my $file_chooser =Gtk2::FileChooserDialog->new (
				'open file',undef,'open','gtk-cancel' => 'cancel','gtk-ok' => 'ok'
				);
$file_chooser->set_select_multiple('FALSE');
$filter=Gtk2::FileFilter->new();
$filter->set_name("jpegs");

$filter->add_mime_type('image/jpeg');


(defined $filter)&&($file_chooser->add_filter($filter));


	if ('ok' eq $file_chooser->run){
				$filename = $file_chooser-> get_filename
				};

$file_chooser->destroy;
return $filename
}

sub dvd_setup {
my ($dvd_opts)=@_;
my ($titles,$dvd_titles);
my $count=1;
my $title_chk;

my %entry_size=(1=>30,2=>15,3=>10,4=>7,5=>6,6=>5);

foreach my $keys (sort {$files{$a}->[3]{title}<=>$files{$b}->[3]{title}} keys %files){
if ($files{$keys}->[0] eq 'dvd_setup'){

				if ($files{$keys}->[3]{title} == $title_chk){
									$count++
									}
									else {
									$count=1
									}

				$$dvd_titles{$files{$keys}->[3]{title}}->{title_name}=$files{$keys}->[3]{title_name} if $files{$keys}->[3]{title_name} !~//;
no strict 'refs';
				$$dvd_titles{$files{$keys}->[3]{title}}->{title_count}=$count;
				$title_chk=$files{$keys}->[3]{title};
				}
}
foreach my $key (sort keys %{$dvd_titles}){
my @arr;
no strict 'refs';
my $lock=0;
		foreach my $keys (sort {$files{$a}->[3]{title}<=>$files{$b}->[3]{title}||$a<=>$b} keys %files){
				$files{$keys}->[3]{title_count}=$$dvd_titles{$key}->{title_count};
				my $titles=basename($files{$keys}->[2],'en.vob',' enn.vob');
					if ($key==$files{$keys}->[3]{title}){
					push @arr,substr($titles,0,$entry_size{$$dvd_titles{$key}->{title_count}});
						if ($files{$keys}->[3]{title_name} ne ''){
							$$dvd_titles{$key}->{title_name}=$files{$keys}->[3]{title_name};
						$lock=1
						}
						else {
						$lock=0
						}	


					}

				}
		if ($lock==0){
			$$dvd_titles{$key}->{title_name}=join "\/",@arr ;
			}
		}
	foreach my $file (sort keys %files){
		if ($files{$file}->[0] eq 'dvd_setup'){
		$files{$file}->[3]{title_name}=$$dvd_titles{$files{$file}->[3]{title}}->{title_name};
		}
}
$$dvd_opts{titles_vbox}->destroy;
	foreach my $keys (sort keys %{$dvd_titles}){
	no strict 'refs';

	my %widgets=(
	'title_hbox'=>{type=>'Gtk2::HBox',action=>'new',opts=>[0,0],wname=>''},
	desc_entry=>{type=>'Gtk2::Entry',action=>'new',opts=>[],wname=>''},
	desc_label=>{type=>'Gtk2::Label',action=>'new',opts=>["Title $keys"],wname=>''},
	);

	my %widget=%{&create_widgets(\%widgets)};
	$$dvd_titles{$keys}->{entry}=$widget{desc_entry};
	$widget{desc_entry}->set_text($$dvd_titles{$keys}->{title_name});
	$widget{desc_entry}->set_width_chars(30);
	$widget{desc_entry}->signal_connect('changed'=>sub{
	$$dvd_titles{$keys}->{title_name}=$widget{desc_entry}->get_text;
		foreach my $key (keys %files){
		$files{$key}->[3]{title_name}=$$dvd_titles{$keys}->{title_name} if $files{$key}->[3]{title} eq $keys;
		}

	});
	&pack_widgets($widget{title_hbox},[$widget{desc_label},$widget{desc_entry}],[0,0,0]);
	&pack_widgets($$dvd_opts{titles_vbox},[$widget{title_hbox}],[0,0,0]);
	}
#		my %size=(1=>[580,400,"1",18],2=>[350,200,"1",14],3=>[260,210,"1",14],4=>[260,210,"1",14],5=>[204,170,"1",12],6=>[204,170,"1",12],7=>[200,140,"1",10],8=>[200,140,"1",10]);
		my %size=(1=>[580,400,"1.6",18],2=>[350,200,"1.6",14],3=>[260,210,"1.333",14],4=>[260,210,"1.333",14],5=>[204,170,"1.333",12],6=>[204,170,"1.333",12],7=>[200,140,"1.6",10],8=>[200,140,"1.6",10]);
$$dvd_opts{dvd}=$options{'dir'}.'/dvd.xml';
$$dvd_opts{spu}=$options{'dir'}.'/spu.xml';
$$dvd_opts{subname} = 'dvd_setup';

$$dvd_opts{create_dvd_button}->set_label("Create DVD File System") if $$dvd_opts{create_dvd_button}->get_label eq '';
&pack_widgets($$dvd_opts{titles_vbox},[$$dvd_opts{create_dvd_button}],[0,0,0]);
&pack_widgets($$dvd_opts{vid_box},[$$dvd_opts{titles_vbox}],[0,0,0]);
$$dvd_opts{vid_box}->show_all;

$$dvd_opts{create_dvd_button}->signal_connect('clicked'=>sub{
my $chk= scalar keys %{$dvd_titles};
foreach my $w ($$dvd_opts{run_box}->get_children){
$w->destroy
}
my %menu_mov=(
		1=>[[80,140,$$dvd_titles{1}->{title_name}]],
		2=>[[210,140,$$dvd_titles{1}->{title_name}],[210,350,$$dvd_titles{2}->{title_name}]],
		3=>[[70,140,$$dvd_titles{1}->{title_name}],[390,140,$$dvd_titles{2}->{title_name}],[230,360,$$dvd_titles{3}->{title_name}]],
		4=>[[70,140,$$dvd_titles{1}->{title_name}],[390,140,$$dvd_titles{2}->{title_name}],[70,360,$$dvd_titles{3}->{title_name}],[390,360,$$dvd_titles{4}->{title_name}]],
		5=>[[30,140,$$dvd_titles{1}->{title_name}],[265,140,$$dvd_titles{2}->{title_name}],[500,140,$$dvd_titles{3}->{title_name}],[130,340,$$dvd_titles{3}->{title_name}],[370,340,$$dvd_titles{5}->{title_name}]],
		6=>[[30,140,$$dvd_titles{1}->{title_name}],[265,140,$$dvd_titles{2}->{title_name}],[500,140,$$dvd_titles{3}->{title_name}],[30,340,$$dvd_titles{4}->{title_name}],[265,340,$$dvd_titles{5}->{title_name}],[500,340,$$dvd_titles{6}->{title_name}]],
		7=>[[25,130,$$dvd_titles{1}->{title_name}],[265,130,$$dvd_titles{2}->{title_name}],[500,130,$$dvd_titles{3}->{title_name}],[25,280,$$dvd_titles{4}->{title_name}],[265,280,$$dvd_titles{5}->{title_name}],[500,280,$$dvd_titles{6}->{title_name}],[265,430,$$dvd_titles{7}->{title_name}]],
		8=>[[25,130,$$dvd_titles{1}->{title_name}],[265,130,$$dvd_titles{2}->{title_name}],[500,130,$$dvd_titles{3}->{title_name}],[25,280,$$dvd_titles{4}->{title_name}],[265,280,$$dvd_titles{5}->{title_name}],[500,280,$$dvd_titles{6}->{title_name}],[135,430,$$dvd_titles{7}->{title_name}],[370,430,$$dvd_titles{8}->{title_name}]]
		);
foreach my $key (sort keys %{$dvd_titles}){
delete $$dvd_titles{$key} if $key > $chk
}

		$sub_stop=0;
		&create_dvd_filesystem($$dvd_opts{menu_file},\%menu_mov,\%size,$dvd_opts,$dvd_titles);
		}
		);

}

sub create_dvd_filesystem {
my ($menu_file,$menu_mov,$size,$dvd_opts,$dvd_titles)=@_;

$ENV{VIDEO_FORMAT}=$broadcast{$options{broadcast}}->{type};
my %menu_mov=%{$menu_mov};
my %size=%{$size};
my %dvd_opts=%{$dvd_opts};
use GD::Simple;

$dvd_opts{buttons}=scalar keys %{$dvd_titles};
my $img1=GD::Simple->new(720,576);
my $green="0,255,0";
my $blue= "0,0,255";
my $red= "255,0,0";
my $white= "255,210,255";
my $black= "0,0,0";
my $menu;

	unless (-e $menu_file ){
		$menu=GD::Simple->new(720,576);
		my $title="DVD Menu";
		my @fore=split /,/,$red;
		my @back=split /,/,$black;
		my $fore=$menu->colorAllocate(@fore);
		my $back=$menu->colorAllocate(@back);
		$menu->fgcolor(($back));
		$menu->bgcolor($back);
		$menu->font("Verdana",32);
		$menu->rectangle(0,0,720,576);
		$menu->moveTo('240','100');
		$menu->interlaced;
		$menu->fgcolor(($fore));
		my $string=$menu->string($title);

		my $home_menu;
		$menu_file='menu_dvd.jpeg';
		open (MENU,">",$menu_file);
		print MENU $menu->jpeg;
		close MENU;
		}

my $type = ($dvd_opts{snap}->get_active==1) ? 1:0;
my %menu_files=(
	'image'=>[$blue,$black],
	'highlight'=>[$green,$blue],
	'select'=>[$red,$white],
	'dvdimage'=>[$blue,$black]
	);
#my %menu_files=(
#	'image'=>[$green,$blue],
#	'highlight'=>[$green,$blue],
#	'select'=>[$green,$red],
#	'dvdimage'=>[$blue,$black]
#	);
my ($text,$size,$width,$height);
$height=$size{$dvd_opts{buttons}}->[1] ;
$width=int($height * $size{$dvd_opts{buttons}}->[2]* 0.9);
(($width/2) =~/\./) ? $width++:$width;
(($height/2) =~/\./) ? $height++:$height;
$size=$width.'x'.$height;
my @menutype=split /\s/,`file -b $menu_file`;
#my @menutype=split /\s/,$menutype1[0];
my $menutype='newFrom'.uc(substr($menutype[0],0,1)).lc(substr($menutype[0],1));
	foreach my $files (keys %menu_files){

my $ext;
$ext='.png' unless $files =~/dvdimage/;
		 $ext='.jpg' if $files =~/dvdimage/;
		my $menu="$options{'dir'}/$files$ext";
		open (GDP,">",$menu) ;
my $img;

if ($files=~/dvdimage/){$img=GD::Simple->$menutype($menu_file)}
else {$img=GD::Simple->new(720,576)};
#		($files=~/dvdimage/)?$img=GD::Simple->$menutype($menu_file):$img=GD::Simple->new(720,576);
		$img->transparent unless $files =~/dvdimage/;

		my $title_ind=1;


			foreach my $keys (@{$menu_mov{$dvd_opts{buttons}}}){
no strict 'refs';

			my @fore=split /,/,$menu_files{$files}[1];
			my @back=split /,/,$menu_files{$files}[0];
			my $fore=$img->colorAllocate(@fore);
			my $back=$img->colorAllocate(@back);
			my $back1=$img->alphaColor(@back,100);
			my %snap=(
			0=>[1],
			1=>[2]
			);

			no strict 'refs';
			my @rect=($keys->[0],$keys->[1],$keys->[0]+$width,$keys->[1]+$size{$dvd_opts{buttons}}->[1]);

		if ($files=~/dvdimage/){
			($type == 1) ? $img->fgcolor($back):$img->fgcolor($fore);
			($type == 1) ? $img->bgcolor($back):$img->bgcolor(undef);
}
else {			#($type == 1) ? $img->fgcolor($back1):$img->fgcolor($fore);
			$img->bgcolor($back1) if $files=~/highlight/;
			$img->fgcolor(undef) if $files=~/highlight/;
}

			my $fontsize=$size{$dvd_opts{buttons}}->[3] * $snap{$type}->[0];
			$img->font("Verdana",$fontsize);
			use Text::Wrap ;
			my $bound = $width-6;
			my $textwidth=$img->stringWidth($keys->[2]);
			my $col= int($bound/$textwidth * length($keys->[2]));

			$Text::Wrap::columns=$col;

			my $text=wrap('','',$keys->[2]);
			my @str_size=$img->stringBounds($text);
			($type==0)? $img->penSize(5):$img->penSize(1);
			$img->rectangle(@rect);
			my $gapx=int(($width-$str_size[0])/2);
			my $gapy=int(($height-$str_size[1])/2);
			$img->moveTo($keys->[0]+$gapx,$keys->[1]+($gapy));
			($type == 1) ? $img->fgcolor(-($fore)):$img->fgcolor(undef);
			my $string=$img->string($text) if $files=~/dvdimage/;
			}
		print GDP $img->png unless $files eq 'dvdimage';
		print GDP $img->jpeg if $files eq 'dvdimage';

		}

my $outdir=$options{'dir'}.'/dvd_tmp';
mkdir $outdir unless (-e $outdir);
my $seconds=$dvd_opts{sec}->get_text;
my $vframes=$seconds * $broadcast{$options{broadcast}}->{fr};
my $frames2=1;
unlink glob($outdir.'/{[0-9]-,dvdjpeg[0-9]}*');
use File::Copy;
my $append_frames=0;
my %menu_jpegs;
if ($type != 1){
foreach my $title (sort {$a<=>$b} keys %{$dvd_titles}){
my $frames=int($vframes/$$dvd_titles{$title}->{title_count});
my $frame_cnt=1;

	foreach my $keys (sort {$files{$a}->[3]{order} <=> $files{$b}->[3]{order}} keys %files){
if ($files{$keys}->[0] eq 'dvd_setup'){
 
if ($files{$keys}->[3]{title}=~/$title/){
			my $prog="ffmpeg -i \"$files{$keys}->[2]\" -f image2 -s $size  -vframes $frames -y $outdir/%d.png ";
			my $out=&run_cmd(undef,undef,$prog,undef,'spumux',$dvd_opts{run_box},undef,$append_frames) if $type != 1;

$append_frames=1;
for (1 .. $frames) {
move ($outdir.'/'.$_.'.png',$outdir.'/'.$title.'-'.$frame_cnt.'.png') or die print $!,"\n";
$frame_cnt++;
}
}
		}
$$dvd_titles{$title}->{frame_count}=$frame_cnt;


}
}

my $gd_frames=$$dvd_titles{1}->{frame_count};
foreach my $keys (keys %{$dvd_titles}){
my $title_frames=$$dvd_titles{$keys}->{frame_count};
$gd_frames=$title_frames if $title_frames < $gd_frames
}
$gd_frames--;

	for (1 .. $gd_frames){
		$menu_jpegs{$_}=undef;
		}


	{
	my $count=1;

	foreach my $keys (@{$menu_mov{$dvd_opts{buttons}}}){
		foreach my $keys1 (sort {$a<=>$b} keys %menu_jpegs){
				no strict 'refs';
				$height=$size{$dvd_opts{buttons}}->[1] * 0.9;

					if (($height / 2) =~/\./){
						$height++
						}

				my $text=$keys->[2];
				my @arr=($count,$count.'-'.$keys1.'.png',$width,$height,$text,$size);
				push @{$menu_jpegs{$keys1}->[0]},[@arr];

				}
		$count++;
		}
	}


	if ($type != 1){
		if ($seconds < .05){
		delete $menu_jpegs{2}
		}
		foreach my $keys1 (sort {$a <=> $b} keys %menu_jpegs){
		&gd_frame($keys1,$dvd_opts{run_box},$menu_file,\%size,\%menu_jpegs,\%menu_mov,$outdir,\$dvd_opts);
		Gtk2->main_iteration while (Gtk2->events_pending)
		}

		}
}
my $input=$outdir.'/dvdjpeg%d.jpeg' ;
my $output=$options{'dir'}.'/menudvd.mpg';
my $time;
	if ($seconds <1){
			$time='25 -loop_input'
			} 
	else {
		$time=$seconds
		}
my $prog;

	if ($type != 1){
		$prog="ffmpeg -i $input -t $time -target pal-dvd -s $broadcast{$options{broadcast}}->{size}  -acodec mp2 -ab 64k -ar 48000 -ac 2 -aspect 4:3 -y $output ";
			}
	else {
		$prog="ffmpeg -loop_input -i $options{'dir'}/dvdimage.jpg -t 25 -target pal-dvd -s $broadcast{$options{broadcast}}->{size}  -acodec mp2 -ab 64k -ar 48000 -ac 2 -aspect 4:3 -y $output ";

		}




#	if ($seconds <1){
#			$time='5 -loop_input'
#			} 
#	else {
#		$time=$seconds
#		}
#m#y $prog;
#	if ($type != 1){
#			$prog="ffmpeg  -i $input  -f s16le -i /dev/zero   -s $broadcast{$options{broadcast}}->{size} -t $time -shortest -qscale 4 -acodec mp2 -ab 64k -ar 48000 -ac 2 -aspect 4:3 -y $output";
#			}
#	else {
#		$prog="ffmpeg -loop_input -i $menu_file -t 5 -f s16le -i /dev/zero -s $broadcast{$options{broadcast}}->{size}  -acodec mp2 -ab 64k -ar 48000 -ac 2 -aspect 4:3 -y $output ";
#		}

&run_cmd(undef,undef,$prog,undef,'spumux',$dvd_opts{run_box},undef,undef) ;
#`ffmpeg  -i $options{'dir'}/menudvd.mpg -target $broadcast{$options{broadcast}}->{target}  -acodec mp2 -ab 64k -ar 48000 -ac 2 -y $options{'dir'}/menudvd.mpg 2>&1`;
	if ($type != 1){
		foreach my $list (sort {$a <=> $b} keys %menu_jpegs){
			unlink $outdir.'/dvdjpeg'.$list.'.jpeg' if -e $outdir.'/dvdjpeg'.$list.'.jpeg';
				foreach my $list2 (sort {$a <=> $b} @{$menu_jpegs{$list}->[0]}){
				unlink "$outdir/$list2->[1]" if -e "$outdir/$list2->[1]";
				}
			}
		}
#my $menu_file_fin="menu1.mpg";
#my $output=$options{'dir'}.'/menudvd.mpg';
open (SPU,">",$dvd_opts{spu});
print SPU "<subpictures>
<stream>
<spu start=\"00:00:00.00\" ";
#print SPU  "highlight=\"$options{'dir'}/highlight.png\"";
print SPU  "highlight=\"$options{'dir'}/highlight.png\"";
#print SPU "select=\"$options{'dir'}/select.png\"";

print SPU " force=\"yes\" 
autooutline=\"infer\"  outlinewidth=\"0\" 
autoorder=\"rows\" > ";
	foreach my $keys (sort {$a <=> $b} keys %{$dvd_titles}){
		my $but_text=$$dvd_titles{$keys}->{title_name};
#my $xtop=$$dvd_titles{$keys}->{title_name};#
#my $ytop=$$dvd_titles{$keys}->{title_name};
#my $xbot=
#my $ybot=
		print SPU "<button name=\"$but_text\" />";
		}
print SPU "</spu>
</stream>
</subpictures>";
my $spumux=$options{'dir'}.'/spu.xml';
my $sputemp="$options{'dir'}/sputemp";
`spumux -m dvd $spumux <$output> \"$options{'dir'}/menu.mpg\" 2>$sputemp`;
my $prog="cat $sputemp";
&run_cmd(undef,undef,$prog,undef,'spumux',$dvd_opts{run_box});
unlink $sputemp;

my $DVD='DVD';
my $dir2=$options{'dir'};
my $dir="$dir2/$DVD";
my $dir1="$dir/VIDEO_TS";

	if (-e $dir1){
		opendir DIR,$dir1;
		my @DIR=readdir DIR;

		foreach my $files (@DIR){
			unlink "$dir1/$files" if substr($files,0,1) ne '.'
			}
		}


my $dvdfile=$dvd_opts{dvd};
unlink $dvdfile;
open (DVD,">>", $dvdfile) or die "$!:";
my $dvdtype=lc($broadcast{$options{broadcast}}->{type});
	print DVD "<dvdauthor dest=\"$dir\">
	<vmgm>
	<menus>
	<pgc>
	<post> jump titleset 1 menu;<\/post>
	<\/pgc>
	<\/menus>
	<\/vmgm>
	<titleset>
	<menus>
	<video format=\"$dvdtype\" aspect=\"4:3\"/>
	<pgc entry=\"root\">
	<pre> button=1024; </pre>\n";
	if ($type != 1){
			print DVD "<post> jump titleset 1 menu  ; </post>\n" 
			}
	print DVD "<vob file=\"$dir2/menu.mpg\" \/>";
		foreach my $keys (sort {$a <=> $b} keys %{$dvd_titles}){
				my $but_text=$$dvd_titles{$keys}->{title_name};
				print DVD "<button name=\"$but_text\">jump title $keys;<\/button>","\n";
				}

	print DVD "<\/pgc>
	<\/menus>";
	print DVD "<titles>
	<video format=\"$dvdtype\" />";

	foreach my $keys (sort {$a<=>$b} keys %{$dvd_titles}){
	print DVD "\n<pgc>\n";

		foreach my $files (sort {$files{$a}->[3]{title}<=>$files{$b}->[3]{title}||$files{$a}->[3]{order}<=>$files{$b}->[3]{order}} keys %files){
			if ($keys==$files{$files}->[3]{title}){
				my $file=$files{$files}->[2];
				my $chapters=&duration($file,$dvd_opts{chap_length},$dvd_opts{cd_work_btn});
				print DVD "<vob file=\"$file\" chapters =$chapters\/>\n";

				}
			}
				if ($keys++ < (scalar keys  %{$dvd_titles})){
					my $next =$keys;
					print DVD "<post>jump title $next;<\/post>";
					}
				else {
					print DVD "<post>call vmgm menu;<\/post>";
					}

			print DVD "<\/pgc>\n";
			}
			print DVD "
			<\/titles>
			<\/titleset>
			<\/dvdauthor>";
			close DVD;
			my $prog='dvdauthor';
			my $opts=" -x $dvdfile";
			&run_cmd(undef,$opts,$prog,undef,$dvd_opts{subname},$dvd_opts{run_box})&& &dvd_burn($dvd_opts{run_box},$dvd_opts{dvd_title});
}

sub gd_frame {
my ($keys1,$sel_opts_vbox,$menu_file,$size,$menu_jpegs,$menu_mov,$outdir)=@_;
	my $gd_sum=scalar keys %{$menu_jpegs};
	my $frame=GD::Simple->newFromJpeg($menu_file,1);
		foreach my $keys2 (@{$$menu_jpegs{$keys1}}){

		my $count=0;
		my $pos_key= scalar @{$keys2};
			foreach my $keys3 (@{$keys2}){
					my $file=$outdir.'/'.$keys3->[1];
					my $inset=GD::Image->newFromPng($file);
					my $title_x1=$$menu_mov{$pos_key}->[$count]->[0] ;
					my $title_x2=$$menu_mov{$pos_key}->[$count]->[0] + $keys3->[2]					;
					my $title_y1=$$menu_mov{$pos_key}->[$count]->[1] ;
					my $title_y2=int($$menu_mov{$pos_key}->[$count]->[1] + ($keys3->[3] *.1));
					my $rect_x2=$title_x1 + $keys3->[2];
					my $pos=$keys3->[3] * 1.1111;
					my $destx=$$menu_mov{$pos_key}->[$count]->[0];
					my $desty=$$menu_mov{$pos_key}->[$count]->[1]+($keys3->[3]*.1);
					$frame->copy($inset,$$menu_mov{$pos_key}->[$count]->[0],$$menu_mov{$pos_key}->[$count]->[1]+($keys3->[3]*.1),0,0,$keys3->[2],$keys3->[3]);
					my @rect_movie=($title_x1,$title_y1,$title_x2,$title_y2);
					$frame->font("Verdana",$$size{$pos_key}->[3]);
					$frame->bgcolor('blue');
					$frame->fgcolor('blue');
					$frame->rectangle(@rect_movie);
					$frame->fgcolor('white');
					$frame->moveTo($title_x1+10,$title_y2);
					$frame->string($keys3->[4]);
					$count++;
					}

			}

my $frame_new=$outdir.'/dvdjpeg'.$keys1.'.jpeg';
open (FRAME,">",$frame_new);
print FRAME $frame->jpeg;

my $append;
	if ($keys1==1){
	$append=0
	}
	else {
	$append=1
	}

&run_cmd(undef,undef,"$keys1 of $gd_sum",undef,'gd',$sel_opts_vbox,undef,$append);

return 1
}



sub dvd_burn {

my ($sel_opts_vbox,$dvd_title,$filename)=@_;
my $dir="$options{'dir'}/DVD";
my $dvd_drive=Gtk2::ComboBox->new_text;
my $DVD_speed=Gtk2::ComboBox->new_text;
my $refresh=Gtk2::Button->new("Refresh");
my $subname='dvd_burn';
$DVD_speed->set_active(0);
my %drivesd=%{&drive_seek('DVD')};
my (undef,undef,undef,$day,$month,$year)= localtime;
$year=$year+1900;
$month=$month+1;


$dvd_title->set_text("DVD-$day-$month-$year") if $dvd_title->get_text eq '';
my $volid= $dvd_title->get_text;
$dvd_title->signal_connect('changed'=>sub{
				$volid=$dvd_title->get_text;
				}
				);

$dvd_drive->append_text("Select Drive/Filename");
foreach my $drives1 (keys %drivesd){
$dvd_drive->append_text($drivesd{$drives1}->{Device_Name}) if $drivesd{$drives1}->{disktype}=~/dvdw|cdw/ ;
}

$dvd_drive->append_text('file');
$dvd_drive->set_active(0);

my $burn_hbox=Gtk2::HBox->new(0,1);
$burn_hbox->set_name('burn');
my $cd_chk=Gtk2::CheckButton->new;
my $label_cd=Gtk2::Label->new("Create image for CD");
my $dvd_burn_btn=Gtk2::Button->new_with_label('Burn DVD');
my $dvd_preview_btn=Gtk2::Button->new_with_label('Preview DVD');

foreach my $key ($sel_opts_vbox->get_children){$key->destroy if $key->get_name eq 'burn'};
&pack_widgets($burn_hbox,[$dvd_preview_btn,$dvd_drive,$DVD_speed,$label_cd,$cd_chk,$dvd_burn_btn,$refresh],[0,0,0]);
my $filenamen;
my $drive;

if (defined $refresh){
$refresh->signal_connect('clicked'=>sub{
my $model=$dvd_drive->get_model;
$model->clear;
$dvd_drive->append_text("Select Drive/Filename");
#$model->set($model->append(), 0,$opticals{2} );
my %dev=%{&drive_seek('DVD')};# or die print $!;

foreach my $dev (keys %dev){
$dvd_drive->append_text($dev{$dev}->{Device_Name}) if $dev{$dev}->{disktype}=~/dvdw|cdw/ 
}
$dvd_drive->append_text('file');
$dvd_drive->set_active(0);
}
);

}
$dvd_preview_btn->signal_connect('clicked'=>sub{
my $dvd=$options{'dir'};
system("dir_dvd_play.pl $dvd");


}
);
$dvd_drive->signal_connect('changed'=>sub{
	foreach my $key (keys %drivesd){
	$drive=$key if $drivesd{$key}->{model} eq $dvd_drive->get_active_text;
	}
my $iso_file=Gtk2::Label->new;

	if ($dvd_drive->get_active_text eq 'file'){
		$filenamen=selection('Choose iso file to save','save',undef,'dvd_burn');
		$iso_file->set_text($filenamen);
		$drivesd{'file'}=$filenamen;
		my $label_iso_file=Gtk2::Label->new('Iso file to save to');

		my $iso_frame=Gtk2::Frame->new;
		my $iso_label_frame=Gtk2::Frame->new;
		$iso_frame->add($iso_file);
		$iso_label_frame->add($label_iso_file);
		$burn_hbox->pack_start($iso_label_frame,0,3,20);
		$burn_hbox->pack_end($iso_frame,0,3,50);
		$burn_hbox->show_all;
		}

no strict 'refs';
my @speed;
	if ($drivesd{$drive}->{disctype} eq 'cdw'){
					@speed=(0,4,8,12,16,20,24,28,32,36,40,44,48,52)
					}
	else {
		@speed=(1,2,3,4,5,6)
		}
$DVD_speed->get_model->clear;
	foreach my $speed (@speed){
	$DVD_speed->append_text($speed)
	}
$cd_chk->signal_connect('clicked'=>sub{
$DVD_speed->get_model->clear;
	if ($cd_chk->get_active==1){
	$drivesd{$drive}->{disctype}='cdw';
	@speed=(0,4,8,12,16,20,24,28,32,36,40,44,48,52)
	}
	else {
	@speed=(1,2,3,4,5,6);
	$drivesd{$drive}->{disctype}='dvdw';
	}

	foreach my $speed (@speed){
	$DVD_speed->append_text($speed)
	}

	}
	);
}
);

$dvd_burn_btn->signal_connect('clicked'=>sub{
	no strict 'refs';
	my ($opts,$prog);
	my $speed=$DVD_speed->get_active_text;
my $drive;
foreach my $keys (keys %drivesd){
$drive=$keys if $drivesd{$keys}->{Device_Name} eq  $dvd_drive->get_active_text;
}

	if ($drivesd{$drive}->{disktype}=~/dvdw/) {
	$prog='growisofs';
		if (length($filename)>1){
		$opts=" -dvd-compat  -V $volid -Z $drivesd{$drive}->{'device'} = $filename"
		}
		else {
		$opts=" -dvd-compat -speed=$speed -Z $drivesd{$drive}->{'device'} -dvd-video -V $volid $dir";
		}
		}

	elsif ($filename eq '' or $dvd_drive->get_active_text =~/file/ ) {
	$prog='genisoimage';
	$filenamen=$options{'dir'}.'/image.iso' if $drivesd{$drive}->{disktype} =~/cdw/;
	$opts=" -dvd-video -V $volid -o  $filenamen $dir" if length($filename)<1;
	}
	else {
	$prog='cdrecord';
	$opts=" dev=$drivesd{$drive}->{device} speed=$speed -dao  $filename";
	}	

	&run_cmd(undef,$opts,$prog,undef,$subname,$sel_opts_vbox);# unless length($filename)>1;

	if ($drivesd{$drive}->{disk} =~/cd/)

	 {
	$prog='cdrecord';
	$opts=" dev=$drivesd{$drive}->{device} speed=$speed -dao  $filenamen";
	&run_cmd(undef,$opts,$prog,undef,$subname,$sel_opts_vbox) if $dvd_drive->get_active_text !~/file/ and length($filename)<1;
	}

	});

my $burn_chk=0;
if ($sel_opts_vbox->get_children eq 'burn') {
$burn_chk=1
}

$sel_opts_vbox->pack_start($burn_hbox,0,0,0) if $burn_chk ==0;
$sel_opts_vbox->show_all;
}



sub dvd_from_dir {
my ($opts)=@_;
my $name_hbox=Gtk2::HBox->new(0,0);
my $name_label=Gtk2::Label->new('Title for DVD');
$name_hbox->pack_start($name_label,0,0,0);
$name_hbox->pack_start($$opts{dvd_title},0,0,0);# or die print $!;
$$opts{sel_opts_vbox}->pack_start($name_hbox,0,0,0);
&dvd_burn($$opts{sel_opts_vbox},$$opts{dvd_title});
}

sub dvd_from_image {
my ($opts)=@_;
my $name_hbox=Gtk2::HBox->new(0,0);
my $filesel=Gtk2::Button->new_with_label('Choose Image File');
my $filename;
$filesel->signal_connect('clicked',sub{$filename=selection('Choose Image File','open',undef,'dvd_from_image');$filesel->set_label($filename)});
$name_hbox->pack_start($filesel,0,0,20);
$$opts{sel_opts_vbox}->pack_start($name_hbox,0,0,20);
&dvd_burn($$opts{sel_opts_vbox},$$opts{dvd_title},$filename);
}

sub dvd_modify {
use XML::Simple;
use strict;

%options=&options_get;
my $dvdfile=$options{'dir'}.'/dvd.xml';  

my %titles;
unless (-e $dvdfile){$dvdfile=selection('Select dvd.xml file','open',undef,'dvd_modify');};
my $dir = dirname ($dvdfile);
my $config=XMLin($dvdfile,ForceArray=>1);
my $count=1;
my %files_list;

my @array;
my $count1=1;

no strict 'refs';
	foreach my $keys (keys %{$config}){ 
	if ($keys eq 'titleset'){
	foreach my $keys2 (@{$config->{$keys}}){

		foreach my $buttons (sort keys %{$keys2->{'menus'}[0]->{'pgc'}[0]->{'button'}}){
						my $indexbut=  $keys2->{'menus'}[0]->{'pgc'}[0]->{'button'}->{$buttons}->{'content'};
						$indexbut=~s/Jump Title //i;
						$indexbut=~s/;//;
						$titles{$indexbut}=$buttons;
						}
		foreach my $keys3 (@{$keys2->{'titles'}}){

			foreach my $keys4 (@{$keys3->{'pgc'}}){
				my $index=1;
					foreach my $keys5 (@{$keys4->{'vob'}}){
						$files_list{$count}=['dvd_setup',undef,$keys5->{'file'},{order=>$index,title=>$count1,title_name=>$titles{$count1},exist=>2}];
$count++;
						$index++;
						}

			$count1++
			}
		}

	}
	}
	}

return %files_list;

#}
}

# Hardware Detection

sub drive_seek {
my $sub=shift;

if ($sub eq "TV Card") {
	my %cap;
	my $dev=join '',`v4l2-ctl --list-devices`;
	$dev=~s/:\n/\t/g;
	my @dev =split /\n/,$dev;
		foreach my $dev (@dev){
			if ($dev=~/video/){
			chomp $dev;
			$dev=~s/\t\t/\t/g;
			my @device=split /\t/,$dev;
	$device[0]=~s/\((?!.*\().+\)$//;
			$cap{$device[1]}={name=>$device[0]};
			}
		}

		foreach my $dev (keys %cap){
			my $input=join '',`v4l2-ctl -I -d $dev`;
			chomp $input;
			my @input=split /:/,$input;
			$input[1]=~s/\(.+$//;
			$cap{$dev}->{input}=$input[1];
			my @input_optsp=`v4l2-ctl --list-inputs -d $dev`;
			my %inputs;
			my $in_key;
				foreach my $inputs (@input_optsp){
				chomp $inputs;
			my @inputs=split /: /,$inputs;
			$inputs[0]=~s/^\s+|\s+$//g;
			$in_key=$inputs[1] if $inputs[0] =~/^Input/;
			$inputs{$in_key}=$inputs[1] if $inputs[0] =~/^Name/;
						}
			my @input_opts;
			foreach my $keys (sort keys %inputs){
			push @input_opts,{$keys=>$inputs{$keys}}
			}
					$cap{$dev}->{input_opts}=[@input_opts];
					my @lists=`v4l2-ctl -l -d $dev`;
						foreach my $list (@lists){
						chomp $list;
						my @hkey=split / \(/,$list;
						$hkey[0]=~s/^\s+//;
						my @value=split /value=/,$list;
						$cap{$dev}->{$hkey[0]}=$value[1];
						}
			my $size=join '',`v4l2-ctl -V -d $dev|grep Width`;
			chomp $size;
			my @size=split /\//,$size;
			$size[1]=~s/.+: //;
			$cap{$dev}->{isize}=$size[1].'x'.$size[2];
		}
	return \%cap;
}
if ($sub eq "Screen"){
		my %wids;
		my $s=Gtk2::Gdk::Screen->get_default or die print $!;
		my $atom_string = Gtk2::Gdk::Atom->intern('STRING');
		my $atom_wm_name = Gtk2::Gdk::Atom->intern('WM_NAME');
		my $atom_class_name = Gtk2::Gdk::Atom->intern('WM_CLASS');
			foreach my $w ($s->get_window_stack){
			my $xid=$w->get_xid;
			my ($type_atom, $format, $sname)   = $w->property_get ($atom_wm_name, $atom_string, 0, 256, 0);
			my ($type_atom, $format, $class)   = $w->property_get ($atom_class_name, $atom_string, 0, 64, 0);
			my $name;
			my @class=split /\0/,$class;
			my $name=&word_wrap($class[1]."\t(".$sname.')',60);
			$wids{$xid}={name=>$name,position=>[$w->get_origin],size=>join ("x",$w->get_size),window=>$w};
			}

		my $width=Gtk2::Gdk::Screen->get_default->get_width;
		my $height=Gtk2::Gdk::Screen->get_default->get_height;
		my $sizec=join('',$width,"x",$height);
		$wids{'full-screen'}={name=>'full-screen',position=>[0,0],size=>$sizec};
		return \%wids;
		}

if ($sub=~/DVD|VCD/i){
my %disks;
my %drives;
my @test1=`bash -c 'type -P udisksctl'`;
my @com;
my $key;
my $info;
if (@test1){
my @com=`ls -1 /sys/block`;
chomp @com;
$info="udisksctl info -b ";

foreach my $line (@com){
my $key=$line;
$disks{$key}={device=>'/dev/'.$key};

}
}
else {
@com=`udisks --enumerate`;
$info="udisks --show-info ";
foreach my $line (@com){
chomp $line;
my @arr=split/\//,$line;
$line=$arr[$#arr];
$disks{$line}={device=>'/dev/'.$line};
}
}

foreach my $dev (keys %disks){
my @list=`$info \"\/dev\/$dev\"`;
if (@test1){
my $devicea=(grep /Drive/, @list)[0];
my $device =(split /\//,$devicea)[-1];
$device=~s/\'//;
my @list2=`udisksctl info -d $device` if length($device)>2;
push @list ,@list2;
}

foreach my $line (@list){
chomp $line;
my @line2=split /:/,$line;
$line2[0]=~s/^\s+//;
$line2[1]=~s/^\s+//;
$disks{$dev}->{$line2[0]}=$line2[1];
}
}





#foreach my $keys (keys %disks){
#;
#no strict 'refs';
#if ($disks{$keys}->{'Optical'} =~/true/ or $disks{$keys}->{'media'}=~/optical/){
#$drives{$keys}={'Blank'=>'0'};#,'filefs'=>'','Drive_Name'=>$disks{$keys}->{Model},'Disk_Name'=>'',device=>''};


#}
#}



foreach my $keys (keys %disks){
foreach my $keys2 (keys %{$disks{$keys}}){
if ($disks{$keys}->{'Optical'} =~/true/ or $disks{$keys}->{'media'}=~/optical/){

chomp $keys2;
$drives{$keys}->{'Blank'}='1' if $disks{$keys}->{'OpticalBlank'}=~/true/ or $disks{$keys}->{'blank'}=~/1/;
$drives{$keys}->{'type'}=$disks{$keys}->{$keys2} if $keys2=~/Type|IDType/i;
$drives{$keys}->{'device'}='/dev/'.$keys;
$drives{$keys}->{'Disk_Name'}=$disks{$keys}->{$keys2} if $keys2=~/(Id)?Label$/i;
$drives{$keys}->{'Device_Name'}=$disks{$keys}->{$keys2} if $keys2=~/Model$/i;
$drives{$keys}->{'mount'}=$disks{$keys}->{$keys2} if $keys2=~/mount paths|MountPoints$/i;
$drives{$keys}->{'disk'}=$disks{$keys}->{$keys2} if $keys2=~/^media$/i;
$drives{$keys}->{'Size'}=$disks{$keys}->{$keys2}/(1024) if $keys2=~/^Size$/i;
$drives{$keys}->{'disk'}=~s/optical_//;
}
}
}



foreach my $keys (keys %drives){
my $disk=$drives{$keys}->{disk};
if ($drives{$keys}->{disk}=~/_rw?$/ and $drives{$keys}->{Blank}=~/1/) {
$disk=~s/_rw?$/w/;
if ($disk=~/dvd/i){
$drives{$keys}->{disktype}=substr($disk,0,3).substr($disk,-1,1)
}
else {
$drives{$keys}->{disktype}=substr($disk,0,2).substr($disk,-1,1)
}
}
else {
$disk=~s/_.+//;
$drives{$keys}->{disktype}=$disk;
}


foreach my $keys2 (keys %{$drives{$keys}}){


}
}

	foreach my $drive (keys %drives){

#	if ($drives{$drive}->{blank}!~/1/){
#		if ($drives{$drive}->{type}=~/udf/) {
#		$drives{$drive}->{disc}='DVD';
#		}
		if ($drives{$drive}->{type}=~/iso9660/){
			if (-e glob($drives{$drive}->{mount}.'/mpegav')){
			$drives{$drive}->{disc}='VCD' ;
			}

		}
#	}
#	else { 
#		if ($drives{$drive}->{media} =~/dvd/i){
#		$drives{$drive}->{disc}='dvdw';
#		}
#		elsif ($drives{$drive}->{media} =~/cd/i){
#		$drives{$drive}->{disc}='cdw'
#		}
#	}

	}
no strict 'refs';

return \%drives
#}
}





}


sub track {
our ($track,$tracks_combo,)=@_;
$track=$tracks_combo->get_active_text;
return $track
}
#}
sub source_search {
my ($source,$sel_cap_hbox,$sel_cap_vbox,$sel_opts_vbox,$delay)=@_;

# Setup hardware lookups

my $media=$source->[1];
no strict 'refs';
my %cap=%{&drive_seek($media)};# if $media=~/TV/;

foreach my $keys (keys %cap){
my $chk=scalar keys %{$cap{$keys}};
if  ($chk lt 2){
delete $cap{$keys};
}
}
my $media_count=scalar keys %cap;
my %opticals=(0=>"No $media found" ,2=>"Select $media" );
if ($media eq 'DVD'){
foreach my $key (keys %cap){
$cap{$key}->{name} =$cap{$key}->{Disk_Name}
}
}
## Hash of Hashes defining Widget placement and actions

no strict 'refs';
my $dvd_modelx=Gtk2::ListStore->new('Glib::String');
$dvd_modelx->set($dvd_modelx->append(), 0,$opticals{2} );
$dvd_modelx->set($dvd_modelx->append(), 0,'Full-Screen' ) if $media eq 'Screen';
my $modelcount=1;
$modelcount++ if $media eq 'Screen';
	foreach my $list (sort {uc($cap{$a}->{name}) cmp uc($cap{$b}->{name})} keys %cap){
		if (length($cap{$list}->{Disk_Name}) >1){
		my $iter=$dvd_modelx->append() ;
		$dvd_modelx->set($iter, 0,$cap{$list}->{Disk_Name});
			$cap{$list}->{ind}=$modelcount;
			$modelcount++
		}
	}



my %widgets=(
	dvd_select=>{type=>'Gtk2::ComboBox',action=>'new_text',opts=>[],wname=>'',width=>30,height=>2},
	dvd_button=>{type=>'Gtk2::Button',action=>'new',opts=>["Capture"],wname=>''},
	titsel_label=>{type=>'Gtk2::Label',action=>'new',opts=>["Select mplayer for\nindividual Titles"],wname=>''},
	titsel=>{type=>'Gtk2::CheckButton',action=>'new',opts=>[],wname=>''},
	track=>{type=>'Gtk2::ComboBox',action=>'new_text',opts=>[],wname=>''},
	chapter_start=>{type=>'Gtk2::ComboBox',action=>'new_text',opts=>[],wname=>'',width=>12},
	chapter_end=>{type=>'Gtk2::ComboBox',action=>'new_text',opts=>[],wname=>'',width=>12},
	capture_table=>{type=>'Gtk2::Table',action=>'new',opts=>[7,7],wname=>''},
	quality=>{type=>'Gtk2::ComboBox',action=>'new_text',opts=>[],wname=>'',width=>7},
	audio_channels=>{type=>'Gtk2::ComboBox',action=>'new_text',opts=>[],wname=>'',width=>7},
	size=>{type=>'Gtk2::ComboBox',action=>'new_text',opts=>[],wname=>'',width=>7},
	isize=>{type=>'Gtk2::ComboBoxEntry',action=>'new_text',opts=>[],wname=>'',width=>14},
	quality_label=>{type=>'Gtk2::Label',action=>'new',opts=>["Quality"],wname=>''},
	audio_channels_label=>{type=>'Gtk2::Label',action=>'new',opts=>["Audio Channels"],wname=>''},
	size_label=>{type=>'Gtk2::Label',action=>'new',opts=>["Scale Output"],wname=>'',width=>11},
	isize_label=>{type=>'Gtk2::Label',action=>'new',opts=>["Input Size"],wname=>''},
	async_label=>{type=>'Gtk2::Label',action=>'new',opts=>["Async"],wname=>''},
	async=>{type=>'Gtk2::ComboBox',action=>'new_text',opts=>[],wname=>'',width=>7},
	file_label=>{type=>'Gtk2::Label',action=>'new',opts=>["Output File"],wname=>''},
	file=>{type=>'Gtk2::Entry',action=>'new',opts=>[],wname=>'',width=>30},
	crop_label=>{type=>'Gtk2::Label',action=>'new',opts=>["crop in\npixels"],wname=>''},
	crop=>{type=>'Gtk2::ComboBox',action=>'new_text',opts=>[],wname=>'',width=>7},
	timer_label=>{type=>'Gtk2::Label',action=>'new',opts=>["time"],wname=>''},
	timer=>{type=>'Gtk2::ComboBoxEntry',action=>'new_text',opts=>[],wname=>'',width=>30},
	fps_label=>{type=>'Gtk2::Label',action=>'new',opts=>["Frames per second"],wname=>''},
	delay_label=>{type=>'Gtk2::Label',action=>'new',opts=>["Delay \n(minutes)"],wname=>''},
	fps=>{type=>'Gtk2::ComboBoxEntry',action=>'new_text',opts=>[],wname=>''},
	refresh=>{type=>'Gtk2::Button',action=>'new',opts=>["Refresh\nDevice"],wname=>''}
	);

my %widget=%{&create_widgets(\%widgets)} or die print $!;
$widget{dvd_select}->set_model($dvd_modelx);
$widget{dvd_select}->set_active(0);
$widget{track}->hide;
$widget{chapter_start}->hide;
$widget{chapter_end}->hide;
my %capture=(
'VCD'=>{
prog=>"vcdxrip",opts=>"-p -C ",hwidgets=>[$widget{dvd_select},$widget{track},$widget{dvd_button},$widget{refresh}]
},

'DVD'=>{
prog=>"dvdunauthor",opts=>'',hwidgets=>[$widget{dvd_select},$widget{titsel_label},$widget{titsel},$widget{track},$widget{chapter_start},$widget{chapter_end},$widget{dvd_button},$widget{delay_label},$delay,$widget{refresh}]
},


"TV Card"=>{prog=>"ffmpeg",hwidgets=>[$widget{dvd_select},$widget{track},$widget{dvd_button}],
table=>$widget{capture_table},
device=>'',
twidgets1=>[0,$widget{isize_label},$widget{quality_label},$widget{async_label},$widget{audio_channels_label}],
twidgets2=>[1,$widget{isize},$widget{quality},$widget{async},$widget{audio_channels}],
twidgets3=>[0,$widget{size_label},$widget{crop_label},$widget{timer_label},$widget{file_label}],
twidgets4=>[1,$widget{size},$widget{crop},$widget{timer},$widget{file}],
quality=> {value=>2,opts=>[1,2,3,4,5,6,7,8,9,10],widget=>$widget{quality},flag=>"-qscale "},
crop=> {value=>8,opts=>[0,8,16,24,32],widget=>$widget{crop}},
opts1=> " -r $broadcast{$options{broadcast}}->{fr} -tvstd ".lc($broadcast{$options{broadcast}}->{type})." -f video4linux2 -i ",
isize=>{value=>1,opts=>['320x224','352x288','480x360','640x480','720x568'],widget=>$widget{isize},flag=>" "},
scale=>{value=>1,opts=>[0.25,0.33,0.5,0.75,1,1.25,1.33,1.5,1.75,2],widget=>$widget{size},flag=>" "},
async=>{value=>24,opts=>[0,1,12,24],widget=>$widget{async},flag=>" -async "},
ac=>{value=>2,opts=>[1,2],widget=>$widget{audio_channels},flag=>" -ac "},
timer=>{value=>'',opts=>["00:30:00","01:00:00","01:30:00","02:00:00","02:30:00","03:00:00","03:30:00",],widget=>$widget{timer},flag=>" -t "}
},



'Screen'=>{prog=>"ffmpeg",hwidgets=>[$widget{dvd_select},$widget{track},$widget{dvd_button},$widget{refresh}],opts=>'',
twidgets1=>[0,$widget{quality_label},$widget{timer_label},$widget{fps_label},$widget{file_label}],
twidgets2=>[1,$widget{quality},$widget{timer},,$widget{fps},$widget{file}],
table=>$widget{capture_table},
opts1=> " -f x11grab -i :0.0",
#size=>{value=>'',opts=>[],widget=>$widget{size},flag=>" -s  "},
osize=>{value=>1,opts=>[1,2,3],widget=>$widget{size},flag=>" -s  "},
timer=>{value=>'',opts=>["00:01:00","00:03:00","00:05:00","00:07:00","00:10:00","00:15:00"],widget=>$widget{timer},flag=>" -t "},
quality=>{value=>'3',opts=>[1,2,3,4,5,6,7,8,9,10],widget=>$widget{quality},flag=>" -qscale "},
fps=>{value=>'5',opts=>[5,10,12,15,20,25],widget=>$widget{fps},flag=>" -r "}
}
);


foreach my $opt ('scale','async','ac','crop','timer','quality','isize'){
	if ($media =~/TV/){
		foreach my $combo ($capture{$media}->{$opt}){
			my $active=0 ;
				foreach my $sel (sort {$a<=>$b} @{$combo->{opts}}){
				$combo->{widget}->append_text($sel);
				$combo->{widget}->set_active($active) if $sel eq $combo->{value} ;
				$active++ ;
				}
			$combo->{widget}->signal_connect('changed'=>sub{
					$combo->{value}=$combo->{widget}->get_active_text if length($combo->{widget}->get_active_text) gt 0;

					}
					);

			}
		}
	
	}

foreach my $opt ('osize','timer','quality','fps'){
	if ($media =~/Screen/){
		foreach my $combo ($capture{$media}->{$opt}){
			my $active=0 ;
				foreach my $sel (sort {$a<=>$b} @{$combo->{opts}}){
				$combo->{widget}->append_text($sel);
				$combo->{widget}->set_active($active) if $sel eq $combo->{value} ;
				$active++ ;
				}
			$combo->{widget}->signal_connect('changed'=>sub{
					$combo->{value}=$combo->{widget}->get_active_text if length($combo->{widget}->get_active_text)>0;
					}
					);

			}
		}
	
	}
$capture{$media}->{table}->set_col_spacings(15) if $capture{$media}->{table};
my $ffmpeg=&version;

&pack_widgets($sel_cap_hbox,[@{$capture{$media}->{hwidgets}}],[0,0,0]);

	if ($capture{$media}->{table}){
	my $hcount;
	foreach my $warr ($capture{$media}->{twidgets1},$capture{$media}->{twidgets2},$capture{$media}->{twidgets3},$capture{$media}->{twidgets4}){
	my $lcount=0;
my $dir=$warr->[0];
shift @{$warr};
	foreach my $lwidgets (@{$warr}){
my $align=Gtk2::Alignment->new($dir,1,0,0);
$align->add($lwidgets);
	$capture{$media}->{table}->attach($align,$hcount,$hcount+1,$lcount,$lcount+1,['fill','shrink'],'shrink',0,0) if defined $lwidgets;
	$lcount++
	}
	$hcount++;
	}
my @r;

foreach my $w (sort $capture{$media}->{table}->get_children){
my $r=$capture{$media}->{table}->child_get_property($w,'bottom-attach');
push @r,$r;
}
use List::Util ('max');
my $align1=Gtk2::Alignment->new(0,1,0,0);
my $align2=Gtk2::Alignment->new(1,1,0,0);
$align1->add($widget{delay_label});
$align2->add($delay);
	$capture{$media}->{table}->attach($align1,0,1,5,6,['fill','shrink'],'shrink',0,0);# or die print $!;# if defined;
	$capture{$media}->{table}->attach($align2,1,2,5,6,['fill','shrink'],'shrink',0,0);# or die print $!;# if defined;
	$sel_cap_vbox->pack_start($capture{$media}->{table},0,0,0);
	$capture{$media}->{table}->show_all;
	}

$sel_cap_hbox->show_all;
$sel_cap_vbox->show_all;
my @opts;


my $drive;
$widget{track}->set_no_show_all(1);
#$widget{track}->hide ;
$capture{$media}->{hwidgets}->[0]->signal_connect('changed'=>sub{
	if ($media=~/DVD/){my $dev;	
		foreach my $keys (keys %cap){
		$dev=$capture{$media}->{hwidgets}->[0]->get_active_text;
		$drive=$cap{$keys}->{device} if $cap{$keys}->{name}=~/$dev/;
#		$drive=$cap{$keys}->{Disk_Name};
		}

		foreach my $comb ($widget{track},$widget{chapter_start},$widget{chapter_end}){
		my $heading=$comb->get_name;
		$heading=~s/_/\n/;
		$heading=~ s/(\w+)/\u\L$1/g;
		$comb->append_text("$heading");
		#foreach my $numb (1..$chapnum){
		#$comb->append_text($numb);
		#}
		#}
		$comb->set_active(0);
		$comb->show;
		$comb->set_sensitive(0);
		}
	$widget{track}->append_text(1);
	my $chapnum;
	}
$widget{titsel}->signal_connect('toggled'=>sub{
my $sens;
my $progname;
if ($widget{titsel}->get_active==1) {
$sens=1;
$progname='mplayer';
my @titles=`mplayer dvd:// -dvd-device $drive -identify -frames 0 2>&1`;
my $titnum;
foreach my $line (@titles){
my @titarr=split /=/,$line;
$titnum=$titarr[1] if $titarr[0]=~/ID_DVD_TITLES/;
}
my $titnumo=$widget{track}->get_model->iter_n_children ;
$widget{track}->get_model->clear;
	foreach my $titlist ('Title',1..$titnum){
	$widget{track}->append_text($titlist)
	};
$widget{track}->set_active(0);


}
	else{
	$sens=0;
	$progname='dvdunauthor';
	}
$capture{DVD}->{prog}=$progname;
	foreach my $w ($widget{track},$widget{chapter_start},$widget{chapter_end}){
	$w->set_sensitive($sens);
	}


}
);
my $chapnum;
	$widget{chapter_start}->signal_connect('changed'=>sub{
		if ($media=~/DVD/){
		my $chapmin=$widget{chapter_start}->get_active_text;
$widget{chapter_end}->get_model->clear;
foreach my $chapend ("Chapter\nEnd",$chapmin..$chapnum){
$widget{chapter_end}->append_text($chapend)
}
}
}
);


	$widget{track}->signal_connect('changed'=>sub{
		if ($media=~/DVD/){
		my $titnumber=$widget{track}->get_active_text;
		my @chapters=`mplayer dvd://$titnumber -dvd-device /dev/sr0 -identify -frames 0 2>&1`;
		$widget{chapter_start}->get_model->clear;
		foreach my $chap (@chapters){
		my @chap=split/=/,$chap;
		$chapnum=$chap[1] if $chap[0]=~/ID_CHAPTERS/;
		}
			foreach my $chap ("Chapter\nStart",1..$chapnum){
			$widget{chapter_start}->append_text($chap)
			}
			$widget{chapter_start}->set_active(0);
					}
		});


		if ($cap{$drive}->{disc}=~/VCD/){
		$media='VCD';
		use File::Glob qw(:globally :nocase);
		my @count = glob(glob('/media/'.$cap{$drive}->{name}.'/mpegav/').'*');# || glob('/home/mike/mpegav/*');
		$widget{track}->append_text("Track");
			for (1 .. scalar @count ){
			$widget{track}->append_text($_)
			}
		$widget{track}->show ;
		$widget{track}->set_active(0);
		}

	elsif ($media=~/TV/){
	$widget{track}->show;
	my $key;
		foreach my $keys (keys %cap){
		my $text=$widget{dvd_select}->get_active_text;
		$key=$keys if $cap{$keys}->{name} eq $widget{dvd_select}->get_active_text;
		}
	$capture{$media}->{device}=$key;
	$widget{track}->get_model->clear;
	$widget{track}->append_text("Select Input");
		foreach my $keys (@{$cap{$key}->{input_opts}}){
		foreach my $input (keys %{$keys}){ 
		$widget{track}->append_text($$keys{$input});
		}
		}

	$widget{track}->set_active(0);

	my %widgetso;
		foreach my $key2 (sort keys %{$cap{$key}}){
			if ($cap{$key}->{$key2}!~/\D/){
			unless ($key2 eq 'ind'){
			$widgetso{$key2.'_label'}={type=>'Gtk2::Label',action=>'new',opts=>[$key2],wname=>''} ;
			$widgetso{$key2}={type=>'Gtk2::CheckButton',action=>'new',opts=>[],wname=>''} if $cap{$key}->{$key2}<2;
			$widgetso{$key2}={type=>'Gtk2::Entry',action=>'new',opts=>[],wname=>'',width=>7} if $cap{$key}->{$key2}>1;
			}
			}
		}
	my %widgeto=%{&create_widgets(\%widgetso)};
		foreach my $w ($capture{$media}->{table}->get_children){
		my $l=$capture{$media}->{table}->child_get_property($w,'left-attach');
		$capture{$media}->{table}->remove($w) if $l=~/4|5/;
		}
	my $wcnt=0;
	foreach my $wid (sort keys %{$cap{$key}}){
		my $wcnt2=$wcnt+1;
		
		my $w1=$widgeto{$wid.'_label'} if defined $widgeto{$wid.'_label'};
		my $w2=$widgeto{$wid} if exists $widgetso{$wid};
		my $align1=Gtk2::Alignment->new(0,1,0,0);
		my $align2=Gtk2::Alignment->new(1,1,0,0);
		$align1->add($w1) if defined($w1);
		$align2->add($w2) if defined($w2);
		$capture{$media}->{table}->attach($align1,4,5,$wcnt,$wcnt2,['fill','shrink'],'shrink',0,0) if $w1=~/Label/;
		$capture{$media}->{table}->attach($align2,5,6,$wcnt,$wcnt2,['fill','shrink'],'shrink',0,0) if defined($w2);
			if ($w2=~/Entry/){
			$w2->set_text($cap{$key}->{$wid});
	$w2->signal_connect('changed'=>sub{$cap{$key}->{$wid}=$w2->get_text,"\n"});
			}
			elsif ($w2=~/Check/){
			$w2->set_active(1) if $cap{$key}->{$wid} ==1;
	$w2->signal_connect('toggled'=>sub{
			my $val=($w2->get_active==1)? 1:0;

			$cap{$key}->{$wid}=$val;
			}
			);
			}
		$wcnt++
		}
#		}


my $table=$capture{$media}->{table};
$table->show_all;
	$widget{track}->signal_connect('changed'=>sub{
		if ($media=~/DVD/){
		my $titnumber=$widget{track}->get_active_text;
		my @chapters=`mplayer dvd;//$titnumber -dvd-device /dev/sr0 -identify -frames 0`;
#		$widget{chapter_start}->get_model->clear;
		foreach my $chap (@chapters){
		$widget{chapter_start}->append_text($chap)
		}
		}




		if ($widget{track}->get_active>=1 and $media!~/DVD/){
				my $input;
					foreach my $keys (@{$cap{$key}->{input_opts}}){
						foreach my $inputw (keys %{$keys}){ 
						$input =$inputw if  $$keys{$inputw} eq $widget{track}->get_active_text;
						}
					}
				$cap{$key}->{input}=" -vc $input ";
				system("v4l2-ctl --set-input $input -d $key  2>&1"); 
				}
				}
					)
				}
				$capture{$media}->{table}->show_all if defined($capture{$media}->{table});	
				}
				);

my $cmdbutton;
if ($media!~/DVD/){
$cmdbutton=$capture{$media}->{hwidgets}->[2]
}
else {
$cmdbutton=$capture{$media}->{hwidgets}->[6]
}

$cmdbutton->signal_connect('clicked'=>sub{
my $opts;
	if ($media=~/DVD|VCD/i){
	my ($sdir,$dev);
	foreach my $key (keys %cap){
	$sdir=$cap{$key}->{Disk_Name} if $cap{$key}->{Disk_Name} eq $widget{dvd_select}->get_active_text;
	$dev=$cap{$key}->{device} if $cap{$key}->{Disk_Name} eq $widget{dvd_select}->get_active_text;
	}
	$sdir=~s/^\s+|\s+$//;
	unless (-e $options{dir}.'/'.$sdir){
	mkdir $options{dir}.'/'.$sdir;
	}
	if ($widget{titsel}->get_active!=1){
	$opts = $capture{$media}->{opts}.' '.$dev;
	}
	else {
my $dvd=" -dvd-device $dev -dumpstream -dumpfile $options{dir}/$sdir/";
my @optarr;
if ($widget{track}->get_active_text!~/\d+/){
push @optarr,$opts='dvd:// '. $dvd.$sdir.'.mpeg'
}
else {
my $out=$dvd.$sdir.'_title_'.$widget{track}->get_active_text;
push @optarr,' dvd://'.$widget{track}->get_active_text,'','',$out;
if ($widget{chapter_start}->get_active_text=~/[0-9]/){
$optarr[1]=' -chapter '.$widget{chapter_start}->get_active_text;
$optarr[4]='_chapts_'.$widget{chapter_start}->get_active_text;
}
if ($widget{chapter_end}->get_active_text=~/[0-9]/){
$optarr[2]='-'.$widget{chapter_end}->get_active_text;

push @optarr,'_'.$widget{chapter_end}->get_active_text
}
push @optarr,'.mpeg';
$opts=join '',@optarr;
}
	}

if ($media=~/VCD/){
	$opts=$opts.' -t '.$widget{track}->get_active_text
	}
	chdir $options{dir}.'/'.$sdir;
	}

	elsif ($media=~/TV/){
	my $cropfilter="old";
		foreach my $line (`ffmpeg -h 2>&1`){
		$cropfilter="new" if $line=~/-vf /
		}
		$capture{$media}->{crop}->{value}=$widget{crop}->get_active_text;
		my ($w,$h)=split /x/,$capture{$media}->{isize}->{value};
		$w=$w-($capture{$media}->{crop}->{value}*2);
		$h=$h-($capture{$media}->{crop}->{value}*2);
		($w,$h)=(int($w*$capture{$media}->{scale}->{value}),int($h*$capture{$media}->{scale}->{value}));
		if ($cropfilter eq 'old'){
		my $crop=$capture{$media}->{crop}->{value};
		$capture{$media}->{crop}->{value}=join ($crop," -croptop "," -cropbottom "," -cropleft "," -cropright ");
		$capture{$media}->{crop}->{value}=$capture{$media}->{crop}->{value}." ".$crop;
		$capture{$media}->{osize}->{value}=' -s '.$w.'x'.$h;			
		}
		else {
		my $crop=$capture{$media}->{crop}->{value};
		$capture{$media}->{crop}->{value}=" -vf \"crop=$crop:$crop:$w:$h\"";
		$capture{$media}->{osize}->{value}=" -vf \"scale=".$w.":".$h."\" ";	
	}

	my @opts;

	foreach my $line ($capture{$media}->{isize},$capture{$media}->{crop},$capture{$media}->{async},$cap{$capture{$media}->{device}}->{input},$capture{$media}->{opts1},$capture{$media}->{device}," -f oss -i /dev/dsp -acodec mp2 -ar 44100 -ab 224k ",$capture{$media}->{ac},$capture{$media}->{quality},$capture{$media}->{osize}->{value},$capture{$media}->{timer}){
		push @opts, $line->{flag}." ".$line->{value} if $line=~/HASH/ and length($line->{value})>0 ;
		push @opts,$line if $line!~/HASH/;

		}
	$opts=" -v 30 s ".join (" ",@opts)." ".$options{dir}.'/'.$widget{file}->get_text ;

	my @exopts;
		foreach my $w ($capture{$media}->{table}->get_children){
		my ($l,$r,$t,$b)=($capture{$media}->{table}->child_get_property($w,"left-attach"),$capture{$media}->{table}->child_get_property($w,"right-attach"),$capture{$media}->{table}->child_get_property($w,"top-attach"),$capture{$media}->{table}->child_get_property($w,"bottom-attach"));

			if ($l=~/5/ and $w->get_child->get_name!~/ind/){
			push @exopts, $w->get_child->get_name."=".$cap{$capture{$media}->{device}}->{$w->get_child->get_name} unless $w->get_name=~/ind/ ;
			}

		}
	my  $exopts=join ",",@exopts;
	system ("v4l2-ctl -c $exopts -d $capture{$media}->{device}");
		}
	elsif ($media=~/Screen/){
		my $key;
		foreach my $keys (keys %cap){
		$key =$keys if $cap{$keys}->{ind} eq $widget{dvd_select}->get_active;
		}
		my @optsc;
		foreach my $opt ('size','fps','position','timer','quality'){
		my $opt1;
				if ($opt=~/position/){
				$opt1=$capture{$media}->{opts1}.'+'.$cap{$key}->{position}->[0].','.$cap{$key}->{position}->[1];
				push @optsc,$opt1;
				}
				elsif ($opt eq 'size'){
				$opt1=' -s '.$cap{$key}->{size};
				push @optsc,$opt1;
				}
				else {
				$opt1=$capture{$media}->{$opt}->{flag}.$capture{$media}->{$opt}->{value} if $opt ne '';
				push @optsc,$opt1;
				};
			}
		$opts=join (" ",@optsc)." ".$options{dir}.'/'.$widget{file}->get_text;
		my $rwin=$cap{$key}->{window};
		$rwin->unmaximize;
		}



$sub_stop=0;
&delay_prog('run_cmd',$delay,0,undef,$opts,$capture{$media}->{prog},undef,'capture',$sel_opts_vbox,undef);
}
); 
if (defined $widget{refresh}){
$widget{refresh}->signal_connect('clicked'=>sub{
my $model=$capture{$media}->{hwidgets}->[0]->get_model;
$model->clear;
$model->set($model->append(), 0,$opticals{2} );

my %dev=%{&drive_seek($media)};# or die print $!;
%dev=%{&drive_seek($media)}; # to make sure vcds get refreshed

foreach my $dev (keys %dev){
$capture{$media}->{hwidgets}->[0]->append_text($dev{$dev}->{Disk_Name}) if $dev{$dev}->{Disk_Name} ne ''
}
$capture{$media}->{hwidgets}->[0]->set_active(0);
}
);
}
}

sub duration {
my ($file,$chap,$cd_work_btn)=@_;
my $arr=`ffmpeg -i \"$file\" 2>&1`;
my @arr=split /\n/,$arr;
my $dur;
	foreach my $out (@arr){
	$dur=$out if $out=~/Duration/
	}
$dur=~s/\s+//g;
$dur=~s/,.+//g;
$dur=~s/Duration://g;
my @sec=split /:/,$dur;
my $length= (($sec[0] * 3600) + ($sec[1] * 60) + $sec[2]);
my $chk=30;
$chap=$chap->get_active_text * 60;
my @chapters;
	until ($chk>=$length){
		my ($sec,$min,$hr)= localtime($chk);

		$hr=$hr-1;
		$hr="0$hr";
		(length($min) == 1)? $min="0$min":$min;
		my $chapter=$hr.':'.$min.':00';
		my $pts=$chapter.'.30';
		push @chapters, $chapter;
				if ($cd_work_btn->get_active == 1){
					push @chapters, $pts;
					}
		$chk=$chk + $chap;
		}
my $chapters='"'. (join ',',@chapters). '"';

return $chapters
}
