diff options
Diffstat (limited to 'perl-install/interactive')
| -rw-r--r-- | perl-install/interactive/curses.pm | 635 | ||||
| -rw-r--r-- | perl-install/interactive/gtk.pm | 1125 | ||||
| -rw-r--r-- | perl-install/interactive/http.pm | 12 | ||||
| -rw-r--r-- | perl-install/interactive/newt.pm | 426 | ||||
| -rw-r--r-- | perl-install/interactive/stdio.pm | 37 |
5 files changed, 1335 insertions, 900 deletions
diff --git a/perl-install/interactive/curses.pm b/perl-install/interactive/curses.pm new file mode 100644 index 000000000..64bdee5c7 --- /dev/null +++ b/perl-install/interactive/curses.pm @@ -0,0 +1,635 @@ +# implementer tree + +# to debug, use something like +# PERLDB_OPTS=TTY=`tty` LC_ALL=fr_FR.UTF-8 xterm -geometry 80x25 -e sh -c 'DISPLAY= perl -d t.pl' + +package interactive::curses; + +use diagnostics; +use strict; +use vars qw(@ISA); + +@ISA = qw(interactive); + +use interactive; +use common; +use log; +use Curses::UI; + +my $SAVEERR; +my $stderr_file = "/tmp/curses-stderr.$$"; +my $padleft = 1; +my $padright = 1; +my $indent = 1; +my $cui; + +sub new { + my ($class) = @_; + if ($::isInstall && !$::local_install) { + system('unicode_start'); #- do not use run_program, we must do it on current console + } + open $SAVEERR, ">&STDERR"; + open STDERR, ">", common::secured_file($stderr_file); + + $cui ||= Curses::UI->new('-color_support' => 1); + + # Set some default terminal size, for serial install + unless ($cui->{'-width'}) { + $cui->{'-width'} = $cui->{'-w'} = $cui->{'-bw'} = 80; + $cui->{'-height'} = $cui->{'-h'} = $cui->{'-bh'} = 25; + } + + bless { cui => $cui }, $class; +} + +sub enter_console { &suspend } +sub leave_console { &end } +sub suspend { $cui && $cui->leave_curses } +sub resume { $cui->reset_curses } +sub end { &suspend; print $SAVEERR $_ foreach cat_($stderr_file); unlink $stderr_file } +sub exit { end(); CORE::exit($_[1] || 0) } +END { end() } + +sub _messages { + my ($width, @messages) = @_; + warp_text(join("\n", @messages), $width); +} + +sub _enable_disable { + my ($w, $disabled) = @_; + + if ($disabled ? $w->{'-is-disabled'} : !$w->{'-is-disabled'}) { + return; + } + $w->{'-is-disabled'} = $disabled; + + if ($disabled) { + add2hash_($w, { '-was-focusable' => $w->focusable, '-was-fg' => $w->{'-fg'}, '-was-bfg' => $w->{'-bfg'} }); + $w->focusable(0); + $w->{'-fg'} = $w->{'-bfg'} = 'blue'; + } else { + $w->focusable($w->{'-was-focusable'}); + $w->{'-fg'} = $w->{'-was-fg'}; + $w->{'-bfg'} = $w->{'-was-bfg'}; + } + $w->intellidraw; +} + +sub filter_widget { + my ($e) = @_; + + if ($e->{title} || $e->{type} eq 'expander') { + $e->{no_indent} = 1; + } + + $e->{type} = 'list' if $e->{type} =~ /iconlist|treelist/; + + #- combo does not allow modifications + $e->{type} = 'entry' if $e->{type} eq 'combo' && !$e->{not_edit}; + + $e->{formatted_list} = [ map { my $t = warp_text(may_apply($e->{format}, $_), 80); $t } @{$e->{list}} ]; + + $e->{default_curses} ||= delete $e->{curses}; +} +sub filter_widgets { + my ($l) = @_; + + filter_widget($_) foreach @$l; + + map { + if (@$_ > 1) { + my $e = { type => 'checkboxes', label => $_->[0]{label}, val => \ (my $_ignored), + list => [ map { $_->{text} } @$_ ], children => $_ }; + filter_widget($e); + $e; + } else { + @$_; + } + } common::group_by { !$_[0]{disabled} && + $_[0]{type} eq 'bool' && $_[1]{type} eq 'bool' + && !$_[1]{label} } @$l; +} + + +sub heights { + my ($best, @fallbacks) = @_; + join(',', $best, grep { $_ < $best } @fallbacks); +} + +sub entry_height { + my ($e) = @_; + to_int(max($e->{curses}{'-height'}, $e->{label_height} || 0)); +} + +sub compute_label_size { + my ($e, $available_width, $o_fixed_width) = @_; + + $e->{label} or return; + + my @text = _messages(min(80, $o_fixed_width || $available_width), $e->{label}); + $e->{label_text_wrapped} = join("\n", @text); + $e->{label_height} = int(@text); + $e->{label_width} = $o_fixed_width || max(map { length } @text); +} +sub compute_label_sizes { + my ($cui, $wanted_widgets) = @_; + + my $available_width = $cui->{'-width'} - 4; + + foreach (@$wanted_widgets) { + compute_label_size($_, $available_width); + } +} + +sub compute_size { + my ($e, $previous_e, $available_width, $o_labels_width) = @_; + + { + my %c = %{$e->{default_curses} || {}}; + $e->{curses} = \%c; + } + #- if $o_labels_width is given, it will be used + compute_label_size($e, $available_width, $o_labels_width); + $e->{curses}{'-x'} ||= + $previous_e && $previous_e->{same_line} ? 1 + $previous_e->{curses}{'-x'} + $previous_e->{curses}{'-width'} : + $e->{no_indent} ? $padleft : + $padleft + $indent + ($e->{label_width} ? $e->{label_width} + 1 : 0); + + my $width_avail = $available_width - $e->{curses}{'-x'}; + + if ($e->{type} eq 'bool') { + my $indent = length("[X] "); + my @text = _messages($width_avail - $indent, $e->{text} || ''); + $e->{curses}{'-height'} ||= heights(int(@text), 4); + $e->{curses}{'-width'} ||= max(map { length } @text) + $indent + 1; + $e->{curses}{'-label'} = join("\n", @text); + } elsif ($e->{type} eq 'combo') { + $e->{curses}{'-height'} ||= 1; + $e->{curses}{'-width'} ||= max(map { length } @{$e->{formatted_list}}) + 3; + } elsif ($e->{type} eq 'checkboxes') { + $e->{curses}{'-height'} ||= heights(map { $_ + 2 } int(@{$e->{formatted_list}}), 10, 4); + $e->{curses}{'-width'} ||= max(map { length } @{$e->{formatted_list}}) + 7; + } elsif ($e->{type} =~ /list/) { + $e->{curses}{'-height'} ||= heights(map { $_ + 2 } int(map { split("\n", $_) } @{$e->{formatted_list}}), 5, 4); + $e->{curses}{'-width'} ||= max(map { length } map { split("\n", $_) } @{$e->{formatted_list}}) + 3; + } elsif ($e->{type} eq 'button') { + my $s = sprintf('< %s >', may_apply($e->{format}, ${$e->{val}})); + $e->{curses}{'-width'} ||= length($s); + } elsif ($e->{type} eq 'expander') { + $e->{curses}{'-width'} ||= length("<+> $e->{text}"); + } elsif (member($e->{type}, qw(text label only_label))) { + my @text = _messages(min(80, $width_avail - 1), ${$e->{val}}); #- -1 because of the scrollbar + $e->{curses}{'-focusable'} = 0; + $e->{curses}{'-height'} ||= heights(int(@text), 10, 4); + $e->{curses}{'-width'} ||= 1 + max(map { length } @text); + } else { + $e->{curses}{'-width'} ||= 20; + } + $e->{curses}{'-height'} ||= 1; + +} + +sub compute_sizes { + my ($cui, $wanted_widgets, $o_labels_width, $b_first_time) = @_; + + my ($available_width, $available_height) = ($cui->{'-width'} - 2, $cui->{'-height'} - 2); + + my $previous; + foreach (@$wanted_widgets) { + compute_size($_, $previous, $available_width, $o_labels_width); + $previous = $_; + } + + my $width = max(map { $_->{curses}{'-x'} + $_->{curses}{'-width'} } @$wanted_widgets); + if ($width > $available_width) { + log::l("oops, could not fit... (width $width > $available_width)\n"); + if ($o_labels_width && $b_first_time) { + log::l("retrying without aligning entries"); + return compute_sizes($cui, $wanted_widgets); + } elsif (!$o_labels_width) { + my $width_no_labels = 4 + max(map { $_->{label} ? $_->{curses}{'-width'} : 0 } @$wanted_widgets); + if ($width_no_labels < $available_width) { + #- trying to force a smaller labels width + log::l("retrying forcing a smaller size for labels ($available_width - $width_no_labels)"); + return compute_sizes($cui, $wanted_widgets, $available_width - $width_no_labels); + } else { + log::l("going on even if labels are too wide ($width_no_labels >= $available_width"); + } + } else { + log::l("going on even if labels can't fit forced to $o_labels_width ($width < $available_width)"); + } + } + my $height; + my $i = @$wanted_widgets; + retry: while (1) { + $height = sum(map { entry_height($_) } grep { !$_->{same_line} } @$wanted_widgets) + 1; + $height > $available_height or last; + while ($i--) { + if ($wanted_widgets->[$i]{curses}{'-height'} =~ s/\d+,//) { +#- warn "retring after modifying $wanted_widgets->[$i]{type}\n"; + if ($wanted_widgets->[$i]{type} eq 'text') { + $wanted_widgets->[$i]{curses}{'-vscrollbar'} = 1; + $wanted_widgets->[$i]{curses}{'-focusable'} = 1; + } + goto retry; + } + } + log::l("oops, could not fit... (height $height > $available_height)\n"); + if ($o_labels_width) { + log::l("retrying without aligning entries"); + compute_sizes($cui, $wanted_widgets); + } else { + #- hum, we need to use expander to split things + my $nb; + my $height = 5; #- room from buttons and expander + foreach (@$wanted_widgets) { + $height += to_int($_->{curses}{'-height'}) if !$_->{same_line}; + $height <= $available_height or die "too_many $nb\n"; + $nb++; + } + internal_error("should have died"); + } + } + + +{ + '-x' => int(($available_width - $width) / 2 - 1), + '-y' => int(($available_height - $height) / 2 - 1), + '-width' => $width + 2, + '-height' => $height + 2, + }; +} + +sub compute_buttons { + my ($common, $validate) = @_; + + my %buttons = (ok => $common->{ok}, cancel => $common->{cancel}); + if (!defined $buttons{cancel} && !defined $buttons{ok}) { + $buttons{cancel} = $::isWizard && !$::Wizard_no_previous ? N("Previous") : N("Cancel"); +# $need_to_die = 1 if !($::isWizard && !$::Wizard_no_previous); + } + $buttons{ok} ||= $::isWizard ? ($::Wizard_finished ? N("Finish") : N("Next")) : N("Ok"); + + my @button_names = grep { $buttons{$_} } 'ok', 'cancel'; + @button_names = reverse(@button_names) if $::isWizard; + + my $same_line = @button_names; + + my %buttons_e = map { + my $name = $_; + my $label = "< $buttons{$name} >"; + + $name => + { type => 'button', val => \$buttons{$name}, same_line => --$same_line, no_indent => 1, + default_curses => { '-height' => 1, '-width' => length($label) }, + clicked_may_quit => $name eq 'ok' ? $validate : sub { '0 but true' }, + }; + } @button_names; + + $buttons_e{$common->{focus_cancel} ? 'cancel' : 'ok'}{focus} = sub { 1 }; + $buttons_e{ok}{disabled} = $common->{ok_disabled} if $common->{ok_disabled}; + + map { $buttons_e{$_} } @button_names; +} + +sub create_widget { + my ($cui, $win, $e, $y, $changed, $focus_out) = @_; + + my $onchange = sub { + my ($f) = @_; + sub { + ${$e->{val}} = $f->(); + $changed->() if $changed; + }; + }; + + #- take the best remaining proposed height + $e->{curses}{'-height'} = to_int($e->{curses}{'-height'}); + + my %options = ('-y' => $y, %{$e->{curses}}); + + if ($e->{label}) { + $e->{label_w} = $win->add(undef, + $e->{label_height} <= 1 ? 'Label' : + ('TextViewer', + '-width' => $e->{label_width}, + '-focusable' => 0, + '-height' => $e->{label_height}), + '-text' => $e->{label_text_wrapped}, + '-y' => $options{'-y'}, '-x' => $padleft + 1, + ); + } + + if (!$e->{same_line}) { + delete $options{'-width'}; + $options{'-padright'} = $padright; + } + $options{'-onblur'} = $focus_out if $focus_out; + + my ($w, $set); + if ($e->{type} eq 'bool') { + $w = $win->add( + undef, 'Checkbox', + '-checked' => ${$e->{val}}, + '-onchange' => $onchange->(sub { $w->get }), + %options); + $set = sub { my $meth = $_[0] ? 'check' : 'uncheck'; $w->$meth; $w->intellidraw }; + } elsif ($e->{type} eq 'expander') { + my $toggle_s = '<+> '; + $e->{label_w} = $win->add(undef, 'Label', '-bold' => 1, '-text' => $toggle_s, %options); + $options{'-x'} += length($toggle_s); + $w = $win->add(undef, 'Buttonbox', '-buttons' => [ { + '-label' => $e->{text}, + '-onpress' => sub { + my $common = { ok => "Close", cancel => '', messages => [ if_($e->{message}, $e->{message}) ] }; + ask_fromW_($cui, $common, $e->{children}); + }, + } ], %options); + } elsif ($e->{type} eq 'button') { + my $clicked_may_quit = delete $options{clicked_may_quit}; + $w = $win->add(undef, 'Buttonbox', '-buttons' => [ { + '-onpress' => $clicked_may_quit || sub { 1 }, + } ], %options); + $w->set_binding('focus-up', Curses::KEY_LEFT()); + $w->set_binding('focus-down', Curses::KEY_RIGHT()); + $set = sub { $w->set_label(0, sprintf('< %s >', may_apply($e->{format}, $_[0]))) }; + } elsif (member($e->{type}, qw(list combo))) { + $w = $win->add(undef, $e->{type} eq 'combo' ? 'Popupmenu' : 'Listbox', + '-values' => $e->{formatted_list}, + '-onchange' => $onchange->(sub { $e->{list}[$w->id] }), + if_($e->{type} eq 'list', + '-vscrollbar' => 1, + '-onselchange' => sub { + #- we don't want selection AND active, so ensuring they are the same + $w->id == $w->get_active_id or $w->set_selection($w->get_active_id); + }), + %options); + $set = sub { + my ($val) = @_; + my $s = may_apply($e->{format}, $val); + eval { + my $id = find_index { $s eq $_ } @{$e->{formatted_list}}; + $w->set_selection($id); + if ($w->can('set_active_id')) { + $w->set_active_id($id); + $w->intellidraw; + } + }; + }; + } elsif ($e->{type} eq 'checkboxes') { + my @selection; + $w = $win->add(undef, 'Listbox', + '-values' => $e->{formatted_list}, + '-vscrollbar' => 1, + '-multi' => 1, + '-onselchange' => sub { + my @new = $w->id; + my %ids = ( + (map { $_ => 1 } difference2(\@new, \@selection)), + (map { $_ => 0 } difference2(\@selection, \@new)), + ); + foreach (keys %ids) { + my $sub_e = $e->{children}[$_]; + ${$sub_e->{val}} = $ids{$_}; + $changed->() if $changed; + } + }, + %options); + $set = sub { + @selection = map_index { if_(${$_->{val}}, $::i) } @{$e->{children}}; + $w->set_selection(@selection); + }; + } elsif ($e->{type} eq 'only_label' && $e->{curses}{'-height'} == 1) { + $w = $win->add(undef, 'Label', '-text' => ${$e->{val}}, + if_($e->{title}, '-bold' => 1), + %options); + } elsif ($e->{type} eq 'label' && $e->{curses}{'-height'} == 1) { + $w = $win->add(undef, 'Label', %options); + $set = sub { $w->text($_[0] || '') }; + } elsif (member($e->{type}, qw(label only_label text))) { + $w = $win->add(undef, 'TextViewer', %options); + $set = sub { + my ($text) = @_; + my $width = $w->{'-sw'} - ($w->{'-vscrollbar'} ? 1 : 0); + $w->text(join("\n", _messages($width, $text))); + }; + } elsif ($e->{type} eq 'range') { + $w = $win->add(undef, 'TextEntry', + '-sbborder' => 1, + '-text' => '', + '-regexp' => '/^\d*$/', + '-onchange' => sub { + $w->text($e->{min}) if $w->text < $e->{min}; + $w->text($e->{max}) if $w->text > $e->{max}; + ${$e->{val}} = $w->text; + $changed->() if $changed; + }, + %options); + $set = sub { $w->text($_[0] || '') }; + } else { + $w = $win->add(undef, $e->{hidden} ? 'PasswordEntry' : 'TextEntry', + '-sbborder' => 1, + '-text' => '', + '-onchange' => $onchange->(sub { $w->text }), + %options); + $set = sub { $w->text($_[0] || '') }; + } + + $e->{w} = $w; + $e->{set} = $set || sub {}; +} + +sub create_widgets { + my ($cui, $win, $l) = @_; + + my $ignore; #-to handle recursivity + my $set_all = sub { + $ignore = 1; + foreach my $e (@$l) { + $e->{set}->(${$e->{val}}); + my $disabled = $e->{disabled} && $e->{disabled}(); + _enable_disable($e->{w}, $disabled); + _enable_disable($e->{label_w}, $disabled) if $e->{label_w}; + } + $ignore = 0; + }; + my $sub_update = sub { + my ($f) = @_; + sub { + return if $ignore; + $f->() if $f; + $set_all->(); + }; + }; + + my $to_focus; + my $y = 1; + foreach (@$l) { + my $e = $_; + + $e->{curses}{clicked_may_quit} = sub { + if (my $v = $e->{clicked_may_quit}()) { + die "exit_mainloop $v"; + } + $set_all->(); + } if $e->{clicked_may_quit}; + + create_widget($cui, $win, $e, $y, $sub_update->($e->{changed}), $sub_update->($e->{focus_out})); + $to_focus ||= $e if $e->{focus} && $e->{focus}->(); + $y += entry_height($e) if !$e->{same_line}; + } + + ($to_focus || $l->[-1])->{w}->focus; + + $set_all->(); + + $set_all; +} + +sub all_entries { + my ($l) = @_; + map { $_, if_($_->{children}, @{$_->{children}}) } @$l; +} + +sub ask_fromW { + my ($o, $common, $l) = @_; + ask_fromW_($o->{cui}, $common, $l); +} + +sub ask_fromW_ { + my ($cui, $common, $l) = @_; + + $l = [ filter_widgets($l) ]; + + my $set_all; + my $validate = sub { + my @all = all_entries($l); + my $e = find { $_->{validate} && !$_->{validate}->() } @all; + $e ||= $common->{validate} && !$common->{validate}() && $all[0]; + if ($e) { + $set_all->(); + $e->{w}->focus if $e->{w}; #- widget may not exist if it is inside an expander + } + !$e; + }; + + my @wanted_widgets = ( + if_(@{$common->{messages}}, { type => 'text', val => \(join("\n", @{$common->{messages}}, ' ')) }), + @$l, + { type => 'label', val => \ (my $_ignore) }, + compute_buttons($common, $validate), + ); + + compute_label_sizes($cui, $l); + my $labels_width = max(map { $_->{label_width} } @$l); + my $window_size; + eval { $window_size = compute_sizes($cui, \@wanted_widgets, $labels_width, 'first_time') } or do { + my ($nb) = $@ =~ /^too_many (\d+)$/ or die; + $nb -= 1; #- remove {messages} + $nb != @$l or internal_error("dead-loop detected"); + + my @l = ( + (@$l)[0 .. $nb - 1], + { type => 'expander', text => N("More"), children => [ (@$l)[$nb .. $#$l] ] }, + ); + return ask_fromW_($cui, $common, \@l); + }; + + my $win = $cui->add(undef, 'Window', + %$window_size, + '-border' => 1, + '-bfg' => 'blue', '-tfg' => 'yellow', '-tbg' => 'blue', '-titlereverse' => 0, + '-focusable' => 1, + if_($common->{title}, '-title' => $common->{title}), + ); + + $set_all = create_widgets($cui, $win, \@wanted_widgets); + + $win->set_binding(\&exit, "\cC"); + $win->set_binding(sub { suspend(); kill 19, $$ }, "\cZ"); + + $cui->focus($win, 1); + eval { $win->modalfocus }; + + my $err = $@; + $cui->delete_object($win); + $cui->draw; + + my ($v) = $err =~ /^exit_mainloop (\S*)/ or die $err; + + $v eq '0 but true' ? 0 : $v; +} + +sub ask_fileW { + my ($o, $opts) = @_; + my ($file, $dir); + + $dir = $opts->{directory} || $opts->{file} && dirname($opts->{file}); + + if ($opts->{save}) { + $file = $o->{cui}->savefilebrowser('-title' => $opts->{title}, '-path' => $dir, '-file' => basename($file)); + } else { + $file = $o->{cui}->loadfilebrowser('-title' => $opts->{title}, '-path' => $dir, '-file' => basename($file)); + } + + my $err; + if (!$file) { + $err = N("No file chosen"); + } elsif (-f $file && $opts->{want_a_dir}) { + $file = dirname($file); + } elsif (-d $file && !$opts->{want_a_dir}) { + $err = N("You have chosen a directory, not a file"); + } elsif (!-e $file && !$opts->{save}) { + $err = $opts->{want_a_dir} ? N("No such directory") : N("No such file"); + } + $err and $o->ask_warn('', $err) or $file; +} + +sub wait_messageW { + my ($o, $title, $message, $message_modifiable) = @_; + + my $w = { title => $title, message_header => $message }; + wait_message_nextW($o, $message_modifiable, $w); + $w; +} + +sub wait_message_nextW { + my ($o, $message, $w) = @_; + + wait_message_endW($o, $w) if $w->{w}; + my $msg = join("\n", _messages($o->{cui}{'-width'}, $w->{message_header} . "\n" . $message)); + $w->{w} = $o->{cui}->add(undef, 'Dialog::Status', '-title' => $w->{title}, '-message' => $msg); + $w->{w}->draw; +} +sub wait_message_endW { + my ($o, $w) = @_; + $o->{cui}->delete_object($w->{w}); + $o->{cui}->draw; +} + +sub wait_message_with_progress_bar { + my ($o, $o_title) = @_; + + my $w = {}; + my $b = before_leaving { $o->wait_message_endW($w) }; + $b, sub { + my ($msg, $current, $total) = @_; + if (!$w->{w} || $w->{total} != $total) { + $o->{cui}->delete_object($w->{w}) if $w->{w}; + + $w->{w} = $o->{cui}->add(undef, + $total ? ('Dialog::Progress', '-max' => $total) : 'Dialog::Status', + if_($o_title, '-title' => $o_title), + '-message' => $msg || $w->{msg}); + $w->{total} = $total; + $w->{msg} = $msg; + } elsif ($msg) { + $w->{w}->message($msg); + } + if ($current) { + $w->{w}->pos($current); + } + $o->{cui}->draw; + }; +} + +1; diff --git a/perl-install/interactive/gtk.pm b/perl-install/interactive/gtk.pm index c55a5f41c..c37143fc3 100644 --- a/perl-install/interactive/gtk.pm +++ b/perl-install/interactive/gtk.pm @@ -1,4 +1,4 @@ -package interactive::gtk; # $Id$ +package interactive::gtk; use diagnostics; use strict; @@ -8,48 +8,57 @@ use vars qw(@ISA); use interactive; use common; -use mygtk2; -use ugtk2 qw(:helpers :wrappers :create); -use Gtk2::Gdk::Keysyms; +use mygtk3; +use ugtk3 qw(:helpers :wrappers :create); my $forgetTime = 1000; #- in milli-seconds sub new { - ($::windowwidth, $::windowheight) = gtkroot()->get_size if !$::isInstall; - goto &interactive::new; + my $w = &interactive::new; + ($w->{windowwidth}, $w->{windowheight}) = mygtk3::root_window_size() if !$::isInstall; + $w; } sub enter_console { my ($o) = @_; $o->{suspended} = common::setVirtual(1) } sub leave_console { my ($o) = @_; common::setVirtual(delete $o->{suspended}) } +sub adapt_markup { + #- nothing needed, the default markup is gtk3's + my ($_o, $s) = @_; return $s; +} -sub exit { ugtk2::exit(@_) } +sub exit { ugtk3::exit(@_) } sub ask_fileW { - my ($_o, $title, $dir) = @_; - my $w = ugtk2->new($title); - $dir .= '/' if $dir !~ m|/$|; - ugtk2::_ask_file($w, $title, $dir); - $w->main; + my ($in, $common) = @_; + + my $w = ugtk3::create_file_selector(%$common); + + my $file; + $w->main(sub { + $file = $w->{chooser}->get_filename; + my $err = ugtk3::file_selected_check($common->{save}, $common->{want_a_dir}, $file); + $err and $in->ask_warn('', $err); + !$err; + }) && $file; } sub create_boxradio { - my ($e, $may_go_to_next, $changed, $double_click) = @_; + my ($e, $onchange_f, $double_click) = @_; - my $boxradio = gtkshow(gtkpack2__(Gtk2::VBox->new(0, 0), - my @radios = gtkradio('', @{$e->{formatted_list}}))); - my $tips = Gtk2::Tooltips->new; + my $boxradio = gtkpack2__(Gtk3::VBox->new, + my @radios = gtkradio('', @{$e->{formatted_list}})); mapn { my ($txt, $w) = @_; + # workaround infamous 6 years old gnome bug #101968: + $w->get_child->set_size_request(mygtk3::get_label_width(), -1) if $e->{alignment} ne 'right' && !$e->{label}; $w->signal_connect(button_press_event => $double_click) if $double_click; - $w->signal_connect(key_press_event => sub { - &$may_go_to_next; + $w->signal_connect(key_press_event => $e->{may_go_to_next}); + $w->signal_connect(clicked => sub { + ${$e->{val}} ne $txt or return; + $onchange_f->(sub { $txt }); }); - $w->signal_connect(clicked => sub { - ${$e->{val}} = $txt; - &$changed; - }); if ($e->{help}) { - gtkset_tip($tips, $w, + $w->set_tooltip_text( ref($e->{help}) eq 'HASH' ? $e->{help}{$txt} : ref($e->{help}) eq 'CODE' ? $e->{help}($txt) : $e->{help}); } @@ -65,19 +74,22 @@ sub create_boxradio { } sub create_treeview_list { - my ($e, $may_go_to_next, $changed, $double_click) = @_; + my ($e, $onchange_f, $double_click) = @_; my $curr; - my $list = Gtk2::ListStore->new("Glib::String"); - my $list_tv = Gtk2::TreeView->new_with_model($list); + my $list = Gtk3::ListStore->new("Glib::String"); + my $list_tv = Gtk3::TreeView->new_with_model($list); $list_tv->set_headers_visible(0); $list_tv->get_selection->set_mode('browse'); - my $textcolumn = Gtk2::TreeViewColumn->new_with_attributes(undef, Gtk2::CellRendererText->new, 'text' => 0); + my $textcolumn = Gtk3::TreeViewColumn->new_with_attributes("", my $renderer = Gtk3::CellRendererText->new, 'text' => 0); $list_tv->append_column($textcolumn); + $renderer->set_property('ellipsize', 'end'); my $select = sub { - $list_tv->set_cursor($_[0], undef, 0); - $list_tv->scroll_to_cell($_[0], undef, 1, 0.5, 0); + my ($path) = @_; + return if !$list_tv->get_model; + $list_tv->set_cursor($path, undef, 0); + Glib::Timeout->add(100, sub { $list_tv->scroll_to_cell($path, undef, 1, 0.5, 0); 0 }); }; my ($starting_word, $start_reg) = ('', '^'); @@ -90,17 +102,17 @@ sub create_treeview_list { Glib::Source->remove($timeout) if $timeout; $timeout = ''; if ($event->keyval >= 0x100) { - &$may_go_to_next if member($event->keyval, ($Gtk2::Gdk::Keysyms{Return}, $Gtk2::Gdk::Keysyms{KP_Enter})); - $starting_word = '' if !member($event->keyval, ($Gtk2::Gdk::Keysyms{Control_L}, $Gtk2::Gdk::Keysyms{Control_R})); + $e->{may_go_to_next}(), return 1 if member($event->keyval, (Gtk3::Gdk::KEY_Return, Gtk3::Gdk::KEY_KP_Enter)); + $starting_word = '' if !member($event->keyval, (Gtk3::Gdk::KEY_Control_L, Gtk3::Gdk::KEY_Control_R)); } else { if (member('control-mask', @{$event->state})) { $c eq 's' or return 1; $start_reg and $start_reg = '', return 1; $curr++; } else { - &$may_go_to_next if $c eq ' '; + $e->{may_go_to_next}(), return 1 if $c eq ' '; - $curr++ if $starting_word eq '' || $starting_word eq $c; + $curr++ if member($starting_word, '', $c); $starting_word .= $c unless $starting_word eq $c; } my @l = @{$e->{formatted_list}}; @@ -111,7 +123,7 @@ sub create_treeview_list { if ($j == @l) { $starting_word = ''; } else { - $select->(Gtk2::TreePath->new_from_string(($j + $curr) % @l)); + $select->(Gtk3::TreePath->new_from_string(($j + $curr) % @l)); } $timeout = Glib::Timeout->add($forgetTime, sub { $timeout = $starting_word = ''; 0 }); @@ -125,9 +137,10 @@ sub create_treeview_list { $list_tv->get_selection->signal_connect(changed => sub { my ($model, $iter) = $_[0]->get_selected; $model && $iter or return; - my $row = $model->get_path_str($iter); - ${$e->{val}} = $e->{list}[$curr = $row]; - &$changed; + $onchange_f->(sub { + my $row = $model->get_path_str($iter); + $e->{list}[$curr = $row]; + }); }); $list_tv->signal_connect(button_press_event => $double_click) if $double_click; @@ -137,80 +150,85 @@ sub create_treeview_list { my $nb = find_index { $_ eq $v } @{$e->{list}}; my ($old_path) = $list_tv->get_cursor; if (!$old_path || $nb != $old_path->to_string) { - $select->(Gtk2::TreePath->new_from_string($nb)); + $select->(Gtk3::TreePath->new_from_string($nb)); } undef $old_path if $old_path; }; }; } -sub create_treeview_tree { - my ($e, $may_go_to_next, $changed, $double_click, $tree_expanded) = @_; - - $tree_expanded = to_bool($tree_expanded); #- to reduce "Use of uninitialized value", especially when debugging +sub __create_tree_model { + my ($e) = @_; my $sep = quotemeta $e->{separator}; - my $tree_model = Gtk2::TreeStore->new("Glib::String", "Gtk2::Gdk::Pixbuf", "Glib::String"); - my $tree = Gtk2::TreeView->new_with_model($tree_model); - $tree->get_selection->set_mode('browse'); - $tree->append_column(Gtk2::TreeViewColumn->new_with_attributes(undef, Gtk2::CellRendererText->new, 'text' => 0)); - $tree->append_column(Gtk2::TreeViewColumn->new_with_attributes(undef, Gtk2::CellRendererPixbuf->new, 'pixbuf' => 1)); - $tree->append_column(Gtk2::TreeViewColumn->new_with_attributes(undef, Gtk2::CellRendererText->new, 'text' => 2)); - $tree->set_headers_visible(0); + my $tree_model = Gtk3::TreeStore->new("Glib::String", if_($e->{image2f}, "Gtk3::Gdk::Pixbuf")); - my ($build_value, $clean_image); - if (exists $e->{image2f}) { - my $to_unref; - $build_value = sub { - my ($text, $image) = $e->{image2f}->($_[0]); - [ $text ? (0 => $text) : @{[]}, - $image ? (1 => $to_unref = gtkcreate_pixbuf($image)) : @{[]} ]; - }; - $clean_image = sub { undef $to_unref }; - } else { - $build_value = sub { [ 0 => $_[0] ] }; - $clean_image = sub {}; - } + my $build_value = sub { + my ($v) = @_; + my $type = 0; + if ($e->{image2f}) { + my $image = $e->{image2f}->($_[0]); + ($type, $v) = (1, gtkcreate_pixbuf($image)) if $image; + } + [ $type => $v ]; + }; - my (%wtree, %wleaves, $size, $selected_via_click); - my $parent; $parent = sub { + my (%wtree, $parent); + $parent = sub { if (my $w = $wtree{"$_[0]$e->{separator}"}) { return $w } my $s = ''; foreach (split $sep, $_[0]) { $wtree{"$s$_$e->{separator}"} ||= $tree_model->append_set($s ? $parent->($s) : undef, $build_value->($_)); - $clean_image->(); - $size++ if !$s; $s .= "$_$e->{separator}"; } $wtree{$s}; }; - #- do some precomputing to not slowdown selection change and key press - my (%precomp, @ordered_keys); - mapn { - my ($root, $leaf) = $_[0] =~ /(.*)$sep(.+)/ ? ($1, $2) : ('', $_[0]); + $tree_model->{path_str_list} = [ map { + my ($root, $leaf) = /(.*)$sep(.+)/ ? ($1, $2) : ('', $_); my $iter = $tree_model->append_set($parent->($root), $build_value->($leaf)); - $clean_image->(); - my $pathstr = $tree_model->get_path_str($iter); - $precomp{$pathstr} = { value => $leaf, fullvalue => $_[0], listvalue => $_[1] }; - push @ordered_keys, $pathstr; - $wleaves{$_[0]} = $pathstr; - } $e->{formatted_list}, $e->{list}; + + $tree_model->get_path_str($iter); + } @{$e->{formatted_list}} ]; + undef $_ foreach values %wtree; undef %wtree; + $tree_model; +} + +sub create_treeview_tree { + my ($e, $onchange_f, $double_click) = @_; + + my $tree_model = __create_tree_model($e); + my $tree = Gtk3::TreeView->new_with_model($tree_model); + $tree->get_selection->set_mode('browse'); + { + my $col = Gtk3::TreeViewColumn->new; + $col->pack_start(my $texrender = Gtk3::CellRendererText->new, 0); + $col->add_attribute($texrender, text => 0); + if ($e->{image2f}) { + $col->pack_start(my $pixrender = Gtk3::CellRendererPixbuf->new, 0); + $col->add_attribute($pixrender, pixbuf => 1); + } + $tree->append_column($col); + } + $tree->set_headers_visible(0); + my $select = sub { my ($path_str) = @_; - $tree->expand_to_path(Gtk2::TreePath->new_from_string($path_str)); - my $path = Gtk2::TreePath->new_from_string($path_str); + my $path = Gtk3::TreePath->new_from_string($path_str); + $tree->expand_to_path($path); $tree->set_cursor($path, undef, 0); - gtkflush(); #- workaround gtk2 bug not honouring centering on the given row if node was closed + gtkflush(); #- workaround gtk3 bug not honouring centering on the given row if node was closed $tree->scroll_to_cell($path, undef, 1, 0.5, 0); }; my $curr = $tree_model->get_iter_first; #- default value - $tree->expand_all if $tree_expanded; + $tree->expand_all if $e->{tree_expanded}; + + my $selected_via_click; $tree->get_selection->signal_connect(changed => sub { my ($model, $iter) = $_[0]->get_selected; @@ -218,8 +236,11 @@ sub create_treeview_tree { undef $curr if ref $curr; my $path = $tree_model->get_path($curr = $iter); if (!$tree_model->iter_has_child($iter)) { - ${$e->{val}} = $precomp{$path->to_string}{listvalue}; - &$changed; + $onchange_f->(sub { + my $path_str = $path->to_string; + my $i = find_index { $path_str eq $_ } @{$tree_model->{path_str_list}}; + $e->{list}[$i]; + }); } else { $tree->expand_row($path, 0) if $selected_via_click; } @@ -232,7 +253,7 @@ sub create_treeview_tree { $tree->toggle_expansion($tree_model->get_path($curr), 0); } else { - &$may_go_to_next; + &{$e->{may_go_to_next}}; } }; @@ -245,8 +266,8 @@ sub create_treeview_tree { Glib::Source->remove($timeout) if $timeout; $timeout = ''; if ($event->keyval >= 0x100) { - &$toggle if member($event->keyval, ($Gtk2::Gdk::Keysyms{Return}, $Gtk2::Gdk::Keysyms{KP_Enter})); - $starting_word = '' if !member($event->keyval, ($Gtk2::Gdk::Keysyms{Control_L}, $Gtk2::Gdk::Keysyms{Control_R})); + &$toggle and return 1 if member($event->keyval, (Gtk3::Gdk::KEY_Return, Gtk3::Gdk::KEY_KP_Enter)); + $starting_word = '' if !member($event->keyval, (Gtk3::Gdk::KEY_Control_L, Gtk3::Gdk::KEY_Control_R)); } else { my $next; if (member('control-mask', @{$event->state})) { @@ -254,25 +275,28 @@ sub create_treeview_tree { $start_reg and $start_reg = '', return 0; $next = 1; } else { - &$toggle if $c eq ' '; - $next = 1 if $starting_word eq '' || $starting_word eq $c; + &$toggle and return 1 if $c eq ' '; + $next = 1 if member($starting_word, '', $c); $starting_word .= $c unless $starting_word eq $c; } my $word = quotemeta $starting_word; my ($after, $best); + my $sep = quotemeta $e->{separator}; my $currpath = $tree_model->get_path_str($curr); - foreach my $v (@ordered_keys) { + mapn { + my ($path_str, $v) = @_; $next &&= !$after; - $after ||= $v eq $currpath; - if ($precomp{$v}{value} =~ /$start_reg$word/i) { + $after ||= $path_str eq $currpath; + $v =~ s/.*$sep//; + if ($v =~ /$start_reg$word/i) { if ($after && !$next) { - ($best, $after) = ($v, 0); + ($best, $after) = ($path_str, 0); } else { - $best ||= $v; + $best ||= $path_str; } } - } + } $tree_model->{path_str_list}, $e->{formatted_list}; if (defined $best) { $select->($best); @@ -290,59 +314,23 @@ sub create_treeview_tree { }); $tree, sub { - my $v = may_apply($e->{format}, $_[0]); - my ($model, $iter) = $tree->get_selection->get_selected; - $select->($wleaves{$v} || return) if !$model || $wleaves{$v} ne $model->get_path_str($iter); - undef $iter if ref $iter; - }; -} - -sub create_list { - my ($e, $may_go_to_next, $changed, $double_click) = @_; - my $l = $e->{list}; - my $list = Gtk2::List->new; - $list->set_selection_mode('browse'); - - my $select = sub { - $list->select_item($_[0]); - }; + my $v = may_apply($e->{format}, $_[0]); + eval { + my $i = find_index { $v eq $_ } @{$e->{formatted_list}}; - my $tips = Gtk2::Tooltips->new; - each_index { - my $item = Gtk2::ListItem->new(may_apply($e->{format}, $_)); - $item->signal_connect(key_press_event => sub { - my ($_w, $event) = @_; - my $c = chr($event->keyval & 0xff); - &$may_go_to_next if $event->keyval < 0x100 ? $c eq ' ' : $c eq "\r" || $c eq "\x8d"; - 0; - }); - $list->append_items(gtkshow($item)); - if ($e->{help}) { - gtkset_tip($tips, $item, - ref($e->{help}) eq 'HASH' ? $e->{help}{$_} : - ref($e->{help}) eq 'CODE' ? $e->{help}($_) : $e->{help}); - } - $item->grab_focus if ${$e->{val}} && $_ eq ${$e->{val}}; - } @$l; + my ($model, $iter) = $tree->get_selection->get_selected; - #- signal_connect'ed after append_items otherwise it is called and destroys the default value - $list->signal_connect(select_child => sub { - my ($_w, $row) = @_; - ${$e->{val}} = $l->[$list->child_position($row)]; - &$changed; - }); - $list->signal_connect(button_press_event => $double_click) if $double_click; + my $new_path_str = $tree_model->{path_str_list}[$i]; + my $old_path_str = $model && $tree_model->get_path_str($iter); - $list, sub { - my ($v) = @_; - eval { - $select->(find_index { $_ eq $v } @$l); - }; + $select->($new_path_str) if $new_path_str ne $old_path_str; + undef $iter if ref $iter; + }; }; } #- $actions is a ref list of $action -#- $action is a { kind => $kind, action => sub { ... }, button => Gtk2::Button->new(...) } +#- $action is a { kind => $kind, action => sub { ... }, button => Gtk3::Button->new(...) } #- where $kind is one of '', 'modify', 'remove', 'add' sub add_modify_remove_action { my ($button, $buttons, $e, $treelist) = @_; @@ -358,354 +346,560 @@ sub add_modify_remove_action { } elsif ($button->{kind} eq 'remove') { ${$e->{val}} = $e->{list}[0]; } - ugtk2::gtk_set_treelist($treelist, [ map { may_apply($e->{format}, $_) } @{$e->{list}} ]); + ugtk3::gtk_set_treelist($treelist, [ map { may_apply($e->{format}, $_) } @{$e->{list}} ]); add_modify_remove_sensitive($buttons, $e); 1; } -sub add_modify_remove_sensitive { - my ($buttons, $e) = @_; - $_->{button}->set_sensitive(@{$e->{list}} != ()) foreach - grep { member($_->{kind}, 'modify', 'remove') } @$buttons; -} +sub add_padding { + my ($w) = @_; + gtknew('HBox', children => [ + 0, gtknew('Alignment', width => $mygtk3::left_padding), + 1, $w + ]); +} -sub ask_fromW { - my ($o, $common, $l, $l2) = @_; - my $ignore = 0; #-to handle recursivity +sub create_widget { + my ($o, $common, $e, $onchange_f, $update, $ignore_ref) = @_; - my $mainw = ugtk2->new($common->{title}, %$o, modal => 1, if__($::main_window, transient => $::main_window)); - - #-the widgets - my (@widgets, @widgets_always, @widgets_advanced, $advanced); - my $tooltips = Gtk2::Tooltips->new; - my $ok_clicked = sub { - !$mainw->{ok} || $mainw->{ok}->get_property('sensitive') or return; - $mainw->{retval} = 1; - Gtk2->main_quit; + my $onchange = sub { + my ($f) = @_; + sub { $onchange_f->($f, @_) }; }; + + my ($w, $real_w, $focus_w, $set); + if ($e->{type} eq 'iconlist') { + $w = Gtk3::Button->new; + $set = sub { + gtkdestroy($e->{icon}); + my $f = $e->{icon2f}->($_[0]); + $e->{icon} = -e $f ? + gtkcreate_img($f) : + Gtk3::WrappedLabel->new(may_apply($e->{format}, $_[0])); + $w->add(gtkshow($e->{icon})); + }; + $w->signal_connect(clicked => sub { + $onchange_f->(sub { next_val_in_array(${$e->{val}}, $e->{list}) }); + $set->(${$e->{val}}); + }); + if ($e->{alignment} eq 'right') { + $real_w = gtknew('HButtonBox', layout => 'start', children_tight => [ $w ]); + } else { + $real_w = gtkpack_(Gtk3::HBox->new(0,10), 1, Gtk3::HBox->new(0,0), 0, $w, 1, Gtk3::HBox->new(0,0)); + } + } elsif ($e->{type} eq 'bool') { + if ($e->{image}) { + $w = ugtk3::gtkadd(Gtk3::CheckButton->new, gtkshow(gtkcreate_img($e->{image}))); + } else { + #- warn "\"text\" member should have been used instead of \"label\" one at:\n", common::backtrace(), "\n" if $e->{label} && !$e->{text}; + $w = Gtk3::CheckButton->new_with_label($e->{text} || ''); + } + $w->signal_connect(clicked => $onchange->(sub { $w->get_active })); + ${$e->{val}} ||= 0; + $set = sub { $w->set_active($_[0] || 0) }; + $real_w = add_padding($w); + } elsif ($e->{type} eq 'only_label') { + my @common = ( + # workaround infamous 6 years old gnome bug #101968: + if_($e->{alignment} ne 'right', width => mygtk3::get_label_width()) + ); + $w = $e->{title} ? + gtknew('Title2', label => escape_text_for_TextView_markup_format(${$e->{val}}), @common) : + gtknew($e->{alignment} eq 'right' ? 'Label_Right' : 'Label_Left', + line_wrap => 1, text_markup => ${$e->{val}}, @common); + } elsif ($e->{type} eq 'label') { + $w = gtknew('WrappedLabel', text_markup => ${$e->{val}}); + $set = sub { $w->set($_[0]) }; + } elsif ($e->{type} eq 'empty') { + $w = gtknew('HBox', height => $e->{height}); + } elsif ($e->{type} eq 'button') { + $w = gtknew(($e->{install_button} ? 'Install_Button' : 'Button'), + text => '', clicked => $e->{clicked_may_quit_cooked}); + $set = sub { + my $w = $w->get_child; + # handle Install_Buttons: + if (ref($w) =~ /Gtk3::HBox/) { + ($w) = find { ref($_) =~ /Gtk3::Label/ } $w->get_children; + } + # guard against 'advanced' widgets that are now in their own dialog + # (instead of in another block child of an expander): + return if !$w; + $w->set_label(may_apply($e->{format}, $_[0])) }; + } elsif ($e->{type} eq 'range') { + my $adj = Gtk3::Adjustment->new(${$e->{val}}, $e->{min}, $e->{max} + ($e->{SpinButton} ? 0 : 1), 1, ($e->{max} - $e->{min}) / 10, 1); + $w = $e->{SpinButton} ? Gtk3::SpinButton->new($adj, 10, 0) : Gtk3::HScale->new($adj); + $w->set_size_request($e->{SpinButton} ? 100 : 200, -1); + $w->set_digits(0); + $adj->signal_connect(value_changed => $onchange->(sub { $adj->get_value })); + $w->signal_connect(key_press_event => $e->{may_go_to_next}); + $set = sub { $adj->set_value($_[0]) }; + } elsif ($e->{type} eq 'expander') { + $e->{grow} = 'fill'; + my $children = [ if_($e->{message}, { type => 'only_label', no_indent => 1, val => \$e->{message} }), @{$e->{children}} ]; + create_widgets_block($o, $common, $children, $update, $ignore_ref); + $w = gtknew('HBox', children_tight => [ + gtknew('Install_Button', text => $e->{text}, + clicked => sub { + eval { ask_fromW($o, { title => $common->{advanced_title} || $common->{title} || N("Advanced") }, $children) }; + if (my $err = $@) { + die $err if $err !~ /^wizcancel/; + } + } + ) + ]); + } elsif ($e->{type} =~ /list/) { + + $e->{formatted_list} = [ map { may_apply($e->{format}, $_) } @{$e->{list}} ]; + + if (my $actions = $e->{add_modify_remove}) { + my @buttons = (N_("Add"), N_("Modify"), N_("Remove")); + # Add Up/Down buttons if their actions are defined + push @buttons, map { if_($actions->{$_}, 'gtk-go-' . $_) } qw(Up Down); + @buttons = map { + my $button = /^gtk-/ ? gtknew('Button', image => gtknew('Image', stock => lc($_))) + : Gtk3::Button->new(translate($_)); + my $kind = $_; + $kind =~ s/^gtk-go-//; + { kind => lc $kind, action => $actions->{$kind}, button => $button, real_kind => $_ }; + } @buttons; + my $modify = find { $_->{kind} eq 'modify' } @buttons; + + my $do_action = sub { + my ($button) = @_; + add_modify_remove_action($button, \@buttons, $e, $w) and $update->(); + }; + + ($w, $set, $focus_w) = create_treeview_list($e, $onchange_f, + sub { $do_action->($modify) if $_[1]->type =~ /^2/ }); + + foreach my $button (@buttons) { + $button->{button}->signal_connect(clicked => sub { $do_action->($button) }); + } + add_modify_remove_sensitive(\@buttons, $e); + + my ($images, $real_buttons) = partition { $_->{real_kind} =~ /^gtk-/ } @buttons; + $real_w = gtkpack_(Gtk3::HBox->new(0,0), + 1, create_scrolled_window($w), + 0, gtkpack__(Gtk3::VBox->new(0,0), + (map { $_->{button} } @$real_buttons), + if_($images, + gtknew('HButtonBox', + layout => 'spread', + children_loose => [ map { $_->{button} } @$images ] + ) + ), + ), + ); + $e->{grow} = 'expand'; + } else { + my $use_boxradio = exists $e->{gtk}{use_boxradio} ? $e->{gtk}{use_boxradio} : @{$e->{list}} <= 8; + + if ($e->{help} || $use_boxradio && $e->{type} ne 'treelist') { + #- used only when needed, as key bindings are dropped by List (ListStore does not seems to accepts Tooltips). + ($w, $set, $focus_w) = create_boxradio($e, $onchange_f, $e->{quit_if_double_click_cooked}); + $real_w = add_padding($w); + } elsif ($e->{type} eq 'treelist') { + ($w, $set) = create_treeview_tree($e, $onchange_f, $e->{quit_if_double_click_cooked}); + } else { + ($w, $set, $focus_w) = create_treeview_list($e, $onchange_f, $e->{quit_if_double_click_cooked}); + } + if (@{$e->{list}} > 10 || $e->{gtk}{use_scrolling}) { + $real_w = create_scrolled_window($w); + $e->{grow} = 'expand'; + } + } + } else { + if ($e->{type} eq "combo") { + my $model; + + my @formatted_list = map { may_apply($e->{format}, $_) } @{$e->{list}}; + $e->{formatted_list} = \@formatted_list; + + if (!$e->{separator}) { + if ($e->{not_edit}) { + $real_w = $w = Gtk3::ComboBoxText->new; + # FIXME: the following causes Gtk-CRITICAL but not solvable at realize time: + first($w->get_child->get_cells)->set_property('ellipsize', 'end') if !$e->{do_not_ellipsize}; + $w->set_wrap_width($e->{gtk}{wrap_width}) if exists $e->{gtk}{wrap_width}; + } else { + $w = Gtk3::ComboBoxText->new_with_entry; + ($real_w, $w) = ($w, $w->get_child); + } + $real_w->set_popdown_strings(@formatted_list); + } else { + $model = __create_tree_model($e); + $real_w = $w = Gtk3::ComboBox->new_with_model($model); + + $w->pack_start(my $texrender = Gtk3::CellRendererText->new, 0); + $w->add_attribute($texrender, text => 0); + if ($e->{image2f}) { + $w->pack_start(my $pixrender = Gtk3::CellRendererPixbuf->new, 0); + $w->add_attribute($pixrender, pixbuf => 1); + } + } + + my $get = sub { + my $i = $model ? do { + my (undef, $iter) = $w->get_active_iter; + my $s = $model->get_string_from_iter($iter); + eval { find_index { $s eq $_ } @{$model->{path_str_list}} }; + } : do { + my $s = $w->get_text; + eval { find_index { $s eq $_ } @formatted_list }; + }; + defined $i ? $e->{list}[$i] : $w->get_text; + }; + $w->signal_connect(changed => $onchange->($get)); + + $set = sub { + my $s = may_apply($e->{format}, $_[0]); + if ($model) { + eval { + my $i = find_index { $s eq $_ } @{$e->{formatted_list}}; + my $path_str = $model->{path_str_list}[$i]; + $w->set_active_iter($model->get_iter_from_string($path_str)); + }; + } else { + $w->set_text($s) if !member($w->get_text, $s, $_[0]); + } + }; + } else { + if ($e->{weakness_check}) { + $w = gtknew('WeaknessCheckEntry'); + } + else { + $w = Gtk3::Entry->new; + } + $w->signal_connect(changed => $onchange->(sub { $w->get_text })); + $w->signal_connect(focus_in_event => sub { $w->select_region(0, -1) }); + $w->signal_connect(focus_out_event => sub { $w->select_region(0, 0) }); + $set = sub { $w->set_text($_[0]) if $_[0] ne $w->get_text }; + if ($e->{type} eq 'file') { + my $button = gtksignal_connect(Gtk3::Button->new_from_stock('gtk-open'), clicked => sub { + my $file = $o->ask_fileW({ + title => $e->{label}, + want_a_dir => to_bool($e->{want_a_dir}), + }); + $set->($file) if $file; + }); + $real_w = gtkpack_(Gtk3::HBox->new(0,0), 1, $w, 0, $button); + } + } + $w->signal_connect(key_press_event => $e->{may_go_to_next}); + if ($e->{hidden}) { + $w->set_visibility(0); + $w->signal_connect(key_press_event => sub { + my (undef, $event) = @_; + if (!$o->{capslock_warned} && member('lock-mask', @{$event->state}) && !$w->get_text) { + $o->{capslock_warned} = 1; + $o->ask_warn('', N("Beware, Caps Lock is enabled")); + } + 0; + }); + } + } + + if (my $focus_out = $e->{focus_out}) { + $w->signal_connect(focus_out_event => sub { $update->($focus_out) }); + } + $real_w ||= $w; + + $e->{w} = $w; + $e->{real_w} = $real_w; + $e->{focus_w} = $focus_w || $w if $e->{type} ne 'empty'; + $e->{set} = $set || sub {}; +} + +sub all_entries { + my ($l) = @_; + map { $_, if_($_->{children}, @{$_->{children}}) } @$l; +} + +sub all_focusable_entries { + my ($l) = @_; + grep { $_->{focus_w} } @$l; +} + +sub all_title_entries { + my ($l) = @_; + grep { $_->{title} } @$l; +} + +sub create_widgets_block { + my ($o, $common, $l, $update, $ignore_ref) = @_; + + my $label_sizegrp = Gtk3::SizeGroup->new('horizontal'); + my $right_label_sizegrp = Gtk3::SizeGroup->new('horizontal'); + my $realw_sizegrp = Gtk3::SizeGroup->new('horizontal'); + + @$l = map_index { + if ($::i && ($_->{type} eq 'expander' || $_->{title})) { + ({ type => 'empty', height => 4 }, $_); + } else { + $_; + } + } @$l; + + foreach my $e (@$l) { + my $onchange_f = sub { + my ($f, @para) = @_; + return if $$ignore_ref; + ${$e->{val}} = $f->(@para); + $update->($e->{changed}); + }; + + create_widget($o, $common, $e, $onchange_f, $update, $ignore_ref); + + my $label_w; + if ($e->{label} || !$e->{no_indent}) { + $label_w = gtknew($e->{alignment} eq 'right' ? 'Label_Right' : 'Label_Left', text_markup => $e->{label} || '', + size_group => ($e->{alignment} eq 'right' ? $right_label_sizegrp : $label_sizegrp), + ); + $realw_sizegrp->add_widget($e->{real_w}); + } + + if ($e->{do_not_expand}) { + $e->{real_w} = gtknew('HBox', children => [ + 0, $e->{real_w}, + 1, gtknew('Label'), + ]); + } + + my $eater = if_($e->{alignment} eq 'right' && !$label_w, gtknew('Label')); + + $e->{real_w} = gtkpack_(Gtk3::HBox->new, + if_($e->{icon}, 0, eval { gtkcreate_img($e->{icon}) }), + if_($eater, 1, $eater), + if_($label_w, $e->{alignment} eq 'right', $label_w), + (!$eater, $e->{real_w}), + ); + } + gtknew('VBox', children => [ map { $_->{grow} || 0, $_->{real_w} } @$l ]); +} + +sub create_widgets { + my ($o, $common, $mainw, $l) = @_; + + my $ignore = 0; #-to handle recursivity my $set_all = sub { $ignore = 1; - $_->{set}->(${$_->{e}{val}}, $_) foreach @widgets_always, @widgets_advanced; - $_->{real_w}->set_sensitive(!$_->{e}{disabled}()) foreach @widgets_always, @widgets_advanced; - $mainw->{ok}->set_sensitive(!$common->{callbacks}{ok_disabled}()) if $common->{callbacks}{ok_disabled}; + my @all = all_entries($l); + $_->{set}->(${$_->{val}}, $_) foreach @all; #- nb: the parameter "$_" is needed for create_boxradio + $_->{disabled} and $_->{real_w}->set_sensitive(!$_->{disabled}()) foreach @all; + $_->{hidden} and $_->{w}->set_visibility(!(ref($_->{hidden}) eq 'CODE' ? $_->{hidden}() : $_->{hidden})) foreach @all; + $mainw->{ok}->set_sensitive(!$common->{ok_disabled}()) if $common->{ok_disabled}; $ignore = 0; }; - my $get_all = sub { - ${$_->{e}{val}} = $_->{get}->() foreach @widgets_always, @widgets_advanced; - }; my $update = sub { my ($f) = @_; return if $ignore; - $get_all->(); - $f->(); + $f->() if $f; $set_all->(); }; - my @label_sizegrp = map { Gtk2::SizeGroup->new('horizontal') } 0 .. 1; - my @realw_sizegrp = map { Gtk2::SizeGroup->new('horizontal') } 0 .. 1; + my $ok_clicked = sub { + !$mainw->{ok} || $mainw->{ok}->get_property('sensitive') or return; + $mainw->{retval} = 1; + Gtk3->main_quit; + }; + + my @all = all_entries($l); + foreach (@all) { + my $e = $_; #- for closures - my $create_widget = sub { - my ($e, $ind) = @_; + # we only consider real widgets (aka ignoring labels and Help/Release Notes/... buttons): + if ((grep { !$_->{install_button} && $_->{type} ne 'only_label' } @all) == 1 || $e->{quit_if_double_click}) { + #- i'm the only one, double click means accepting + $e->{quit_if_double_click_cooked} = sub { $_[1]->type =~ /^2/ && $ok_clicked->() }; + } - my $may_go_to_next = sub { + if ($e->{clicked_may_quit}) { + $e->{clicked_may_quit_cooked} = sub { + $mainw->{rwindow}->hide; + if (my $v = $e->{clicked_may_quit}()) { + $mainw->{retval} = $v; + Gtk3->main_quit; + } + $mainw->{rwindow}->show; + $update->(); + }; + } + + $e->{may_go_to_next} = sub { my (undef, $event) = @_; if (!$event || ($event->keyval & 0x7f) == 0xd) { - if ($ind == $#widgets) { - @widgets == 1 ? $ok_clicked->() : $mainw->{ok}->grab_focus; + my @current_all = all_focusable_entries($l); + my $ind = eval { find_index { $_ == $e } @current_all }; + if (my $e_ = $current_all[$ind+1]) { + $e_->{focus_w}->grab_focus; } else { - $widgets[$ind+1]{focus_w}->grab_focus; + @current_all == 1 ? $ok_clicked->() : $mainw->{ok}->grab_focus; } - return 1; #- prevent an action on the just grabbed focus + 1; #- prevent an action on the just grabbed focus + } else { + 0; } }; - my $changed = sub { $update->(sub { $common->{callbacks}{changed}($ind) }) }; + } - my ($w, $real_w, $focus_w, $set, $get, $grow); - if ($e->{type} eq 'iconlist') { - $w = Gtk2::Button->new; - $set = sub { - gtkdestroy($e->{icon}); - my $f = $e->{icon2f}->($_[0]); - $e->{icon} = -e $f ? - gtkcreate_img($f) : - Gtk2::WrappedLabel->new(may_apply($e->{format}, $_[0])); - $w->add(gtkshow($e->{icon})); - }; - $w->signal_connect(clicked => sub { - $set->(${$e->{val}} = next_val_in_array(${$e->{val}}, $e->{list})); - $changed->(); - }); - $real_w = gtkpack_(Gtk2::HBox->new(0,10), 1, Gtk2::HBox->new(0,0), 0, $w, 1, Gtk2::HBox->new(0,0)); - } elsif ($e->{type} eq 'bool') { - if ($e->{image}) { - $w = ugtk2::gtkadd(Gtk2::CheckButton->new, gtkshow(gtkcreate_img($e->{image}))); - } else { -#- warn "\"text\" member should have been used instead of \"label\" one at:\n", common::backtrace(), "\n" if $e->{label} && !$e->{text}; - $w = Gtk2::CheckButton->new_with_label($e->{text}); - } - $w->signal_connect(clicked => $changed); - $set = sub { $w->set_active($_[0]) }; - $get = sub { $w->get_active }; - } elsif ($e->{type} eq 'label') { - $w = Gtk2::WrappedLabel->new(${$e->{val}}); - $set = sub { $w->set($_[0]) }; - } elsif ($e->{type} eq 'button') { - $w = Gtk2::Button->new_with_label(''); - $w->signal_connect(clicked => sub { - $get_all->(); - $mainw->{rwindow}->hide; - if (my $v = $e->{clicked_may_quit}()) { - $mainw->{retval} = $v; - Gtk2->main_quit; - } - $mainw->{rwindow}->show; - $set_all->(); - }); - $set = sub { $w->child->set_label(may_apply($e->{format}, $_[0])) }; - } elsif ($e->{type} eq 'range') { - my $want_scale = !$::expert; - my $adj = Gtk2::Adjustment->new(${$e->{val}}, $e->{min}, $e->{max} + ($want_scale ? 1 : 0), 1, ($e->{max} - $e->{min}) / 10, 1); - $adj->signal_connect(value_changed => $changed); - $w = $want_scale ? Gtk2::HScale->new($adj) : Gtk2::SpinButton->new($adj, 10, 0); - $w->set_size_request($want_scale ? 200 : 100, -1); - $w->set_digits(0); - $w->signal_connect(key_press_event => $may_go_to_next); - $set = sub { $adj->set_value($_[0]) }; - $get = sub { $adj->get_value }; - } elsif ($e->{type} =~ /list/) { - - $e->{formatted_list} = [ map { may_apply($e->{format}, $_) } @{$e->{list}} ]; - - if (my $actions = $e->{add_modify_remove}) { - my @buttons = map { - { kind => lc $_, action => $actions->{$_}, button => Gtk2::Button->new(translate($_)) }; - } N_("Add"), N_("Modify"), N_("Remove"); - my $modify = find { $_->{kind} eq 'modify' } @buttons; - - my $do_action = sub { - my ($button) = @_; - add_modify_remove_action($button, \@buttons, $e, $w) and $changed->(); - }; + # add asterisks before titles when there're more than one: + my @all_titles = all_title_entries($l); + if (2 <= @all_titles) { + ${$_->{val}} = mygtk3::asteriskize(${$_->{val}}) foreach @all_titles; + } - ($w, $set, $focus_w) = create_treeview_list($e, $may_go_to_next, $changed, - sub { $do_action->($modify) if $_[1]->type =~ /^2/ }); - $e->{saved_default_val} = ${$e->{val}}; + my $box = create_widgets_block($o, $common, $l, $update, \$ignore); - foreach my $button (@buttons) { - $button->{button}->signal_connect(clicked => sub { $do_action->($button) }); - } - add_modify_remove_sensitive(\@buttons, $e); + foreach my $e (@all) { + $e->{w}->set_tooltip_text($e->{help}) if $e->{help} && !ref($e->{help}); + } - $real_w = gtkpack_(Gtk2::HBox->new(0,0), - 1, create_scrolled_window($w), - 0, gtkpack__(Gtk2::VBox->new(0,0), map { $_->{button} } @buttons)); - $grow = 1; - } else { + $box, $set_all; +} + +sub add_modify_remove_sensitive { + my ($buttons, $e) = @_; + $_->{button}->set_sensitive(@{$e->{list}} != ()) foreach + grep { member($_->{kind}, 'modify', 'remove') } @$buttons; +} - my $quit_if_double_click = - #- i'm the only one, double click means accepting - @$l == 1 || $e->{quit_if_double_click} ? - sub { $_[1]->type =~ /^2/ && $ok_clicked->() } : ''; +sub filter_widgets { + my ($l) = @_; - my @para = ($e, $may_go_to_next, $changed, $quit_if_double_click); - my $use_boxradio = exists $e->{gtk}{use_boxradio} ? $e->{gtk}{use_boxradio} : @{$e->{list}} <= 8; + foreach my $e (all_entries($l)) { + $e->{no_indent} = 1 if member($e->{type}, 'list', 'treelist', 'expander', 'bool', 'only_label'); + } +} - if ($e->{help}) { - #- used only when needed, as key bindings are dropped by List (ListStore does not seems to accepts Tooltips). - ($w, $set, $focus_w) = $use_boxradio ? create_boxradio(@para) : create_list(@para); - } elsif ($e->{type} eq 'treelist') { - ($w, $set) = create_treeview_tree(@para, $e->{tree_expanded}); - $e->{saved_default_val} = ${$e->{val}}; #- during realization, signals will mess up the default val :( - } else { - if ($use_boxradio) { - ($w, $set, $focus_w) = create_boxradio(@para); - } else { - ($w, $set, $focus_w) = create_treeview_list(@para); - $e->{saved_default_val} = ${$e->{val}}; - } - } - if (@{$e->{list}} > 10) { - $real_w = create_scrolled_window($w); - $grow = 1; - } - } - } else { - if ($e->{type} eq "combo") { +my $help_path = "/usr/share/doc/installer-help"; - my @formatted_list = map { may_apply($e->{format}, $_) } @{$e->{list}}; +sub is_help_file_exist { + my ($_o, $id) = @_; + # just ignore anchors: + $id =~ s/#.*//; + -e "$help_path/$id.html"; +} - my @l = sort { $b <=> $a } map { length } @formatted_list; - my $width = $l[@l / 16]; # take the third octile (think quartile) +sub load_from_uri { + my ($view, $url) = @_; + $view->load_uri(get_html_file($::o, $url)); +} - if ($e->{not_edit} && $width < 160) { #- ComboBoxes do not have an horizontal scroll-bar. This can cause havoc for long strings (eg: diskdrake Create dialog box in expert mode) - $w = Gtk2::ComboBox->new_text; - } else { - $w = Gtk2::Combo->new; - $w->set_use_arrows_always(1); - $w->entry->set_editable(!$e->{not_edit}); - $w->disable_activate; - } +sub get_html_file { + my ($o, $url) = @_; + my $anchor; + ($url, $anchor) = $url =~ /(.*)#(.*)/ if $url =~ /#/; + $url .= '.html' if $url !~ /\.html$/; + $url = find { -e $_ } map { "$help_path/${_}" } + map { + my $id = $_; + require lang; + map { ("$_/$id") } map { $_, lc($_) } (split ':', lang::getLANGUAGE($o->{locale}{lang})), ''; + } $url; + $url = "file://$url"; + $anchor ? "$url#$anchor" : $url; +} - $w->set_popdown_strings(@formatted_list); - $w->set_text(ref($e->{val}) ? may_apply($e->{format}, ${$e->{val}}) : $formatted_list[0]) if $w->isa('Gtk2::ComboBox'); - ($real_w, $w) = ($w, $w->entry); +sub display_help_window { + my ($o, $common) = @_; + if (my $file = $common->{interactive_help_id}) { + require Gtk3::WebKit2; + my $view = gtknew('WebKit2_WebView'); + + load_from_uri($view, $file); + + my $w = ugtk3->new(N("Help"), modal => 1); + gtkadd($w->{rwindow}, + gtkpack_(Gtk3::VBox->new, + 1, create_scrolled_window(gtkset_border_width($view, 5), + [ 'never', 'automatic' ], + ), + 0, Gtk3::HSeparator->new, + 0, gtkpack(create_hbox('end'), + gtknew('Button', text => N("Close"), clicked => sub { Gtk3->main_quit }) + ), + ), + ); + mygtk3::set_main_window_size($w->{rwindow}); + $w->{real_window}->grab_focus; + $w->{real_window}->show_all; + $w->main; + return; + } elsif (my $message = $common->{interactive_help}->()) { + $o->ask_warn(N("Help"), $message); + } +} - #- FIXME workaround gtk suckiness (set_text generates two 'change' signals, one when removing the whole, one for inserting the replacement..) - my $idle; - $w->signal_connect(changed => sub { - $idle ||= Glib::Idle->add(sub { undef $idle; $changed->(); 0 }); - }); +sub display_help { + my ($o, $common) = @_; + # not very safe but we run in a restricted environment anyway: + my $f = '/tmp/help.txt'; + if ($common->{interactive_help}) { + output($f, $common->{interactive_help}->()); + } + local $ENV{LC_ALL} = $::o->{locale}{lang} || 'C'; + system('display_installer_help', $common->{interactive_help_id} || $f, $o->{locale}{lang}); +} - $set = sub { - my $s = may_apply($e->{format}, $_[0]); - $w->set_text($s) if $s ne $w->get_text && $_[0] ne $w->get_text; - }; - $get = sub { - my $s = $w->get_text; - my $i = eval { find_index { $s eq $_ } @formatted_list }; - defined $i ? $e->{list}[$i] : $s; - }; - } else { - $w = Gtk2::Entry->new; - $w->signal_connect(changed => $changed); - $w->signal_connect(focus_in_event => sub { $w->select_region(0, -1) }); - $w->signal_connect(focus_out_event => sub { $w->select_region(0, 0) }); - $set = sub { $w->set_text($_[0]) if $_[0] ne $w->get_text }; - $get = sub { $w->get_text }; - } - $w->signal_connect(key_press_event => $may_go_to_next); - $w->set_visibility(0) if $e->{hidden}; - } - $w->signal_connect(focus_out_event => sub { - $update->(sub { $common->{callbacks}{focus_out}($ind) }); - }); - $tooltips->set_tip($w, $e->{help}) if $e->{help} && !ref($e->{help}); +sub ask_fromW { + my ($o, $common, $l) = @_; - $real_w ||= $w; - $real_w = gtkpack_(Gtk2::HBox->new, - if_($e->{icon}, 0, eval { gtkcreate_img($e->{icon}) }), - 0, gtkadd_widget($label_sizegrp[$e->{advanced} ? 1 : 0], $e->{label}), - 1, gtkadd_widget($realw_sizegrp[$e->{advanced} ? 1 : 0], $real_w), - ) if !$real_w->isa("Gtk2::CheckButton") || $e->{icon} || $e->{label}; + filter_widgets($l); - { e => $e, w => $w, real_w => $real_w, focus_w => $focus_w || $w, - get => $get || sub { ${$e->{val}} }, set => $set || sub {}, grow => $grow }; - }; - @widgets_always = map_index { $create_widget->($_, $::i) } @$l; - @widgets_advanced = map_index { $create_widget->($_, $::i + @$l) } @$l2; + my $mainw = ugtk3->new($common->{title}, %$o, if__($::main_window, transient => $::main_window), + if_($common->{icon}, icon => $common->{icon}), banner_title => $common->{banner_title}, + ); + + my ($box, $set_all) = create_widgets($o, $common, $mainw, $l); $mainw->{box_allow_grow} = 1; my $pack = create_box_with_title($mainw, @{$common->{messages}}); - mygtk2::set_main_window_size($mainw->{rwindow}) if $mainw->{pop_it} && (@$l || $mainw->{box_size} == 200); - - my @before_widgets_advanced = ( - (map { { grow => 0, real_w => Gtk2::WrappedLabel->new($_) } } @{$common->{advanced_messages}}), - { grow => 0, real_w => Gtk2::HSeparator->new }, - ); - - my $first_time = 1; - my $set_advanced = sub { - ($advanced) = @_; - $update->($common->{callbacks}{advanced}) if $advanced && !$first_time; - foreach (@before_widgets_advanced, @widgets_advanced) { - my $w = $_->{embed_scroll} || $_->{real_w}; - $advanced ? $w->show : $w->hide; - } - @widgets = (@widgets_always, if_($advanced, @widgets_advanced)); - $mainw->sync; #- for $set_all below (mainly for the set of clist) - $first_time = 0; - $set_all->(); #- must be done when showing advanced lists (to center selected value) - }; - my $advanced_button = [ $common->{advanced_label}, - sub { - my ($w) = @_; - $set_advanced->(!$advanced); - $w->child->set_label($advanced ? $common->{advanced_label_close} : $common->{advanced_label}); - } ]; + mygtk3::set_main_window_size($mainw->{rwindow}) if $mainw->{pop_it} && !$common->{auto_window_size} && (@$l || $mainw->{box_size} == 200); my @more_buttons = ( - if_($common->{interactive_help}, - [ N("Help"), sub { - my $message = $common->{interactive_help}->() or return; - $o->ask_warn(N("Help"), $message); - }, 1 ]), + if_($common->{interactive_help} || $common->{interactive_help_id}, + [ gtknew('Install_Button', text => N("Help"), + clicked => sub { display_help($o, $common) }), undef, 1 ]), if_($common->{more_buttons}, @{$common->{more_buttons}}), ); - if ($::expert && @$l2) { - $common->{advanced_state} = 1; - $advanced_button->[0] = $common->{advanced_label_close}; - } - my $buttons_pack = ($common->{ok} || !exists $common->{ok}) && $mainw->create_okcancel($common->{ok}, $common->{cancel}, '', @more_buttons, if_(@$l2, $advanced_button)); - - my @widgets_to_pack; - foreach my $l (\@widgets_always, if_(@widgets_advanced, [ @before_widgets_advanced, @widgets_advanced ])) { - my @grouped; - my $add_grouped = sub { - if (@grouped == 0) { - } elsif (@grouped == 1) { - push @widgets_to_pack, 0 => $grouped[0]{real_w}; - } else { - my $scroll = create_scrolled_window(gtkpack__(Gtk2::VBox->new(0,0), map { $_->{real_w} } @grouped), - [ 'automatic', 'automatic' ], 'none'); - $_->{embed_scroll} = $scroll foreach @grouped; - push @widgets_to_pack, 1 => $scroll; - } - @grouped = (); - }; - foreach (@$l) { - if ($_->{grow}) { - $add_grouped->(); - push @widgets_to_pack, 1 => $_->{real_w}; - } else { - push @grouped, $_; - } - } - $add_grouped->(); - } + my $buttons_pack = ($common->{ok} || !exists $common->{ok}) && $mainw->create_okcancel($common->{ok}, $common->{cancel}, '', @more_buttons); - gtkpack_($pack, @widgets_to_pack); + gtkpack_($pack, 1, gtknew('ScrolledWindow', shadow_type => 'none', child => $box)) if @$l; if ($buttons_pack) { $pack->pack_end(gtkshow($buttons_pack), 0, 0, 0); } - ugtk2::gtkadd($mainw->{window}, $pack); - $set_advanced->($common->{advanced_state}); - - my $widget_to_focus = - $common->{focus_cancel} ? $mainw->{cancel} : - @widgets && ($common->{focus_first} || !$mainw->{ok} || @widgets == 1 && member(ref($widgets[0]{focus_w}), "Gtk2::TreeView", "Gtk2::RadioButton")) ? - $widgets[0]{focus_w} : - $mainw->{ok}; + ugtk3::gtkadd($mainw->{window}, $pack); + $set_all->(); + + my $entry_to_focus = find { $_->{focus} && $_->{focus}() } @$l; + my $widget_to_focus = $entry_to_focus ? $entry_to_focus->{focus_w} : + $common->{focus_cancel} ? $mainw->{cancel} : + @$l && (!$mainw->{ok} || @$l == 1 && member(ref($l->[0]{focus_w}), "Gtk3::TreeView", "Gtk3::RadioButton")) ? + $l->[0]{focus_w} : + $mainw->{ok}; $widget_to_focus->grab_focus if $widget_to_focus; - my $check = sub { - my ($f) = @_; - sub { - $get_all->(); - my ($error, $focus) = $f->(); - - if ($error) { - $set_all->(); - if (my $to_focus = $widgets[$focus || 0]) { - $to_focus->{focus_w}->grab_focus; - } else { - log::l("ERROR: bad entry number given to focus " . backtrace()); - } - } - !$error; - }; + my $validate = sub { + my @all = all_entries($l); + my $e = find { $_->{validate} && !$_->{validate}->() } @all; + $e ||= $common->{validate} && !$common->{validate}() && $all[0]; + if ($e) { + $set_all->(); + $e->{focus_w}->grab_focus; + } + !$e; }; - $_->{set}->($_->{e}{saved_default_val} || next) foreach @widgets_always, @widgets_advanced; - $mainw->main(map { $check->($common->{callbacks}{$_}) } 'complete', 'canceled'); + $mainw->main($validate); } sub ask_browse_tree_info_refW { my ($o, $common) = @_; add2hash($common, { wait_message => sub { $o->wait_message(@_) } }); - ugtk2::ask_browse_tree_info($common); + ugtk3::ask_browse_tree_info($common); } @@ -720,37 +914,78 @@ sub ask_from__add_modify_removeW { $o->ask_from($title, $message, $l, %callback); } +my $reuse_timeout; + sub wait_messageW { - my ($_o, $title, $messages) = @_; + my ($o, $title, $message, $message_modifiable) = @_; + + my $to_modify = Gtk3::Label->new(scalar warp_text(ref $message_modifiable ? '' : $message_modifiable)); - my $to_modify; - my @l = map { ref $_ ? (0, $_) : (1, $to_modify = Gtk2::Label->new(scalar warp_text($_))) } @$messages; - $l[0] = 0; #- force first one + Glib::Source->remove($reuse_timeout) if $reuse_timeout; $reuse_timeout = ''; my $Window = gtknew('MagicWindow', - title => $title, - pop_it => !$::isInstall, + if_($title, title => $title), + pop_it => defined $o->{pop_wait_messages} ? $o->{pop_wait_messages} : 1, + pop_and_reuse => $::isInstall, modal => 1, - if__($::main_window, transient_for => $::main_window), - child => gtknew('VBox', padding => 4, border_width => 10, children => \@l), + $::isInstall ? (banner => gtknew('Install_Title', text => $message)) : (), + no_Window_Manager => exists $o->{no_Window_Manager} ? $o->{no_Window_Manager} : !$::isStandalone, + child => gtknew('VBox', padding => 4, border_width => 10, children => [ + 1, $to_modify, + if_(ref($message_modifiable), 0, $message_modifiable), + ]), ); - $Window->signal_connect(expose_event => sub { $Window->{displayed} = 1; 0 }); + mygtk3::enable_sync_flush($Window); $Window->{wait_messageW} = $to_modify; - mygtk2::sync($Window) while !$Window->{displayed}; + mygtk3::sync_flush($Window); $Window; } sub wait_message_nextW { - my ($_o, $messages, $Window) = @_; - my $msg = warp_text(join "\n", @$messages); - return if $msg eq $Window->{wait_messageW}->get_text; #- needed otherwise no expose_event :( + my ($_o, $message, $Window) = @_; + return if $message eq $Window->{wait_messageW}->get_text; #- needed otherwise no draw :( $Window->{displayed} = 0; - $Window->{wait_messageW}->set($msg); - mygtk2::sync($Window) while !$Window->{displayed}; + $Window->{wait_messageW}->set($message); + mygtk3::sync($Window) while !$Window->{displayed}; } sub wait_message_endW { my ($_o, $Window) = @_; - mygtk2::may_destroy($Window); - mygtk2::flush(); + if ($Window->{pop_and_reuse}) { + $reuse_timeout = Glib::Timeout->add(100, sub { + mygtk3::destroy_previous_popped_and_reuse_window(); + }); + } else { + mygtk3::may_destroy($Window); + mygtk3::flush(); + } +} + +sub wait_message_with_progress_bar { + my ($in, $o_title) = @_; + + my $progress = gtknew('ProgressBar'); + my $w = $in->wait_message($o_title, $progress); + my $displayed; + $progress->signal_connect(draw => sub { $displayed = 1; 0 }); + $w, sub { + my ($msg, $current, $total) = @_; + if ($msg) { + $w->set($msg); + } + + if ($total) { + $progress or internal_error('You must first give some text to display'); + my $fraction = min(1, $current / $total); + if ($fraction != $progress->get_fraction) { + $progress->set_fraction($fraction); + $progress->show; + $displayed = 0; + mygtk3::flush() while !$displayed; + } + } else { + $progress->hide; + mygtk3::flush(); + } + }; } sub kill { @@ -759,12 +994,4 @@ sub kill { @tempory::objects = (); } -sub ok { - N("Ok"); -} - -sub cancel { - N("Cancel"); -} - 1; diff --git a/perl-install/interactive/http.pm b/perl-install/interactive/http.pm index 6825ee007..70017c41d 100644 --- a/perl-install/interactive/http.pm +++ b/perl-install/interactive/http.pm @@ -1,4 +1,4 @@ -package interactive::http; # $Id$ +package interactive::http; use diagnostics; use strict; @@ -115,7 +115,7 @@ sub ask_fromW { open_stdout(); # re-open for writing cont_stdout(N("Error")); - print $q->h1(N("Error")), $q->p("Sorry, you can not go back"); + print $q->h1(N("Error")), $q->p("Sorry, you cannot go back"); goto redisplay; } each_index { @@ -136,15 +136,15 @@ sub p { } sub wait_messageW { - my ($_o, $_title, $messages) = @_; + my ($_o, $_title, $message, $message_modifiable) = @_; cont_stdout(); print "\n" . CGI::p(); - p(@$messages); + p($message, $message_modifiable); } sub wait_message_nextW { - my ($_o, $messages, $_w) = @_; - p(@$messages); + my ($_o, $message, $_w) = @_; + p($message); } sub wait_message_endW { my ($_o, $_w) = @_; diff --git a/perl-install/interactive/newt.pm b/perl-install/interactive/newt.pm deleted file mode 100644 index 47d77b54a..000000000 --- a/perl-install/interactive/newt.pm +++ /dev/null @@ -1,426 +0,0 @@ -package interactive::newt; # $Id$ - -use diagnostics; -use strict; -use vars qw(@ISA); - -@ISA = qw(interactive); - -use interactive; -use common; -use log; -use Newt::Newt; #- !! provides Newt and not Newt::Newt - -my ($width, $height) = (80, 25); -my @wait_messages; - -sub new { - if ($::isInstall) { - system('unicode_start'); #- do not use run_program, we must do it on current console - { - local $ENV{LC_CTYPE} = "en_US.UTF-8"; - Newt::Init(1); - } - c::setlocale(); - } else { - Newt::Init(0); - } - Newt::Cls(); - Newt::SetSuspendCallback(); - ($width, $height) = Newt::GetScreenSize(); - open STDERR, ">/dev/null" if $::isStandalone && !$::testing; - bless {}, $_[0]; -} - -sub enter_console { Newt::Suspend() } -sub leave_console { Newt::Resume() } -sub suspend { Newt::Suspend() } -sub resume { Newt::Resume() } -sub end { Newt::Finished() } -sub exit { end(); exit($_[1]) } -END { end() } - -sub messages { - my ($width, @messages) = @_; - warp_text(join("\n", @messages), $width - 9); -} - -sub myTextbox { - my ($allow_scroll, $free_height, @messages) = @_; - - my @l = messages($width, @messages); - my $h = min($free_height - 13, int @l); - - my $want_scroll; - if ($h < @l) { - if ($allow_scroll) { - $want_scroll = 1; - } else { - # remove the text, no other way! - @l = @l[0 .. $h-1]; - } - } - - my $mess = Newt::Component::Textbox(1, 0, my $w = max(map { length } @l) + 1, $h, $want_scroll); - $mess->TextboxSetText(join("\n", @l)); - $mess, $w + 1, $h; -} - -sub separator { - my $blank = Newt::Component::Form(\undef, '', 0); - $blank->FormSetWidth($_[0]); - $blank->FormSetHeight($_[1]); - $blank; -} -sub checkval { $_[0] && $_[0] ne ' ' ? '*' : ' ' } - -sub ask_fromW { - my ($o, $common, $l, $l2) = @_; - - if (@$l == 1 && $l->[0]{list} && @{$l->[0]{list}} == 2 && listlength(map { split "\n" } @{$common->{messages}}) > 20) { - #- special ugly case, esp. for license agreement - my $e = $l->[0]; - my $ok_disabled = $common->{callbacks} && delete $common->{callbacks}{ok_disabled}; - ($common->{ok}, $common->{cancel}) = map { may_apply($e->{format}, $_) } @{$e->{list}}; - do { - ${$e->{val}} = ask_fromW_real($o, $common, [], $l2) ? $e->{list}[0] : $e->{list}[1]; - } while $ok_disabled && $ok_disabled->(); - 1; - } elsif ((any { $_->{type} ne 'button' } @$l) || @$l < 5) { - &ask_fromW_real; - } else { - $common->{cancel} = N("Do") if $common->{cancel} eq ''; - my $r; - do { - my @choices = map { - my $s = simplify_string(may_apply($_->{format}, ${$_->{val}})); - $s = "$_->{label}: $s" if $_->{label}; - { label => $s, clicked_may_quit => $_->{clicked_may_quit} }; - } @$l; - #- replace many buttons with a list - my $new_l = [ { val => \$r, type => 'list', list => \@choices, format => sub { $_[0]{label} }, sort => 0 } ]; - ask_fromW_real($o, $common, $new_l, $l2) and return; - } until $r->{clicked_may_quit}->(); - 1; - } -} - -sub ask_fromW_real { - my ($o, $common, $l, $l2) = @_; - my $ignore; #-to handle recursivity - my $old_focus = -2; - - my @l = $common->{advanced_state} ? @$l2 : @$l; - my @messages = (@{$common->{messages}}, if_($common->{advanced_state}, @{$common->{advanced_messages}})); - - #-the widgets - my (@widgets, $total_size, $has_scroll); - - my $label_width; - my $get_label_width = sub { - $label_width ||= max(map { length($_->{label}) } @l); - }; - - my $set_all = sub { - $ignore = 1; - $_->{set}->(${$_->{e}{val}}) foreach @widgets; -# $_->{w}->set_sensitive(!$_->{e}{disabled}()) foreach @widgets; - $ignore = 0; - }; - my $get_all = sub { - ${$_->{e}{val}} = $_->{get}->() foreach @widgets; - }; - my $create_widget = sub { - my ($e, $ind) = @_; - - $e->{type} = 'list' if $e->{type} =~ /iconlist/; - - #- combo does not exist, fallback to a sensible default - $e->{type} = $e->{not_edit} ? 'list' : 'entry' if $e->{type} eq 'combo'; - - my $changed = sub { - return if $ignore; - return $old_focus++ if $old_focus == -2; #- handle special first case - $get_all->(); - - #- TODO: this is very rough :( - $common->{callbacks}{$old_focus == $ind ? 'changed' : 'focus_out'}->($ind); - - $set_all->(); - $old_focus = $ind; - }; - - my ($w, $real_w, $set, $get, $expand, $size, $invalid_choice, $extra_text); - if ($e->{type} eq 'bool') { - my $subwidth = $width - $get_label_width->() - 9; - my @text = messages($subwidth, $e->{text} || ''); - $size = @text; - $w = Newt::Component::Checkbox(shift(@text), checkval(${$e->{val}}), " *"); - if (@text) { - $extra_text = Newt::Component::Textbox(-1, -1, $subwidth, $size - 1, 0); - $extra_text->TextboxSetText(join("\n", @text)); - } - $set = sub { $w->CheckboxSetValue(checkval($_[0])) }; - $get = sub { $w->CheckboxGetValue == ord '*' }; - } elsif ($e->{type} eq 'button') { - $w = Newt::Component::Button(simplify_string(may_apply($e->{format}, ${$e->{val}}))); - } elsif ($e->{type} eq 'treelist') { - $e->{formatted_list} = [ map { may_apply($e->{format}, $_) } @{$e->{list}} ]; - my $data_tree = interactive::helper_separator_tree_to_tree($e->{separator}, $e->{list}, $e->{formatted_list}); - - my $count; $count = sub { - my ($t) = @_; - 1 + ($t->{_leaves_} ? int @{$t->{_leaves_}} : 0) - + ($t->{_order_} ? sum(map { $count->($t->{$_}) } @{$t->{_order_}}) : 0); - }; - $size = $count->($data_tree); - - my $prefered_size = @l == 1 && $height > 30 ? 10 : 5; - my $scroll; - if ($size > $prefered_size && !$o->{no_individual_scroll}) { - $has_scroll = $scroll = 1; - $size = $prefered_size; - } - - $w = Newt::Component::Tree($size, $scroll); - - my $wi; - my $add_item = sub { - my ($text, $index, $parents) = @_; - $text = simplify_string($text, $width - 10); - $wi = max($wi, length($text) + 3 * @$parents + 4); - $w->TreeAdd($text, $index, $parents); - }; - - my @data = ''; - my $populate; $populate = sub { - my ($node, $parents) = @_; - if (my $l = $node->{_order_}) { - each_index { - $add_item->($_, 0, $parents); - $populate->($node->{$_}, [ @$parents, $::i ]); - } @$l; - } - if (my $l = $node->{_leaves_}) { - foreach (@$l) { - my ($leaf, $data) = @$_; - $add_item->($leaf, int(@data), $parents); - push @data, $data; - } - } - }; - $populate->($data_tree, []); - - $w->TreeSetWidth($wi + 1); - $get = sub { - my $i = $w->TreeGetCurrent; - $invalid_choice = $i == 0; - $data[$i]; - }; - $set = sub { - my ($data) = @_; - eval { - my $i = find_index { $_ eq $data } @data; - $w->TreeSetCurrent($i); - } if $data; - 1; - }; - } elsif ($e->{type} =~ /list/) { - $size = @{$e->{list}}; - my $prefered_size = @l == 1 && $height > 30 ? 10 : 5; - my $scroll; - if ($size > $prefered_size && !$o->{no_individual_scroll}) { - $has_scroll = $scroll = 1; - $size = $prefered_size; - } - - $w = Newt::Component::Listbox($size, $scroll ? 1 << 2 : 0); #- NEWT_FLAG_SCROLL - - my @l = map { - my $t = simplify_string(may_apply($e->{format}, $_), $width - 10); - $w->ListboxAddEntry($t, $_); - $t; - } @{$e->{list}}; - - $w->ListboxSetWidth(max(map { length($_) } @l) + 3); # 3 added for the scrollbar (?) - $get = sub { $w->ListboxGetCurrent }; - $set = sub { - my ($val) = @_; - each_index { - $w->ListboxSetCurrent($::i) if $val eq $_; - } @{$e->{list}}; - }; - } else { - $w = Newt::Component::Entry('', 20, ($e->{hidden} && 1 << 11) | (1 << 2)); - $get = sub { $w->EntryGetValue }; - $set = sub { $w->EntrySet($_[0], 1) }; - } - $total_size += $size || 1; - - #- !! callbacks must be kept otherwise perl will free them !! - #- (better handling of addCallback needed) - - { e => $e, w => $w, real_w => $real_w || $w, expand => $expand, callback => $changed, - get => $get || sub { ${$e->{val}} }, set => $set || sub {}, - extra_text => $extra_text, invalid_choice => \$invalid_choice }; - }; - @widgets = map_index { $create_widget->($_, $::i) } @l; - - $_->{w}->addCallback($_->{callback}) foreach @widgets; - - $set_all->(); - - my $grid = Newt::Grid::CreateGrid(3, max(1, sum(map { $_->{extra_text} ? 2 : 1 } @widgets))); - my $i; - foreach (@widgets) { - $grid->GridSetField(0, $i, 1, ${Newt::Component::Label($_->{e}{label})}, 0, 0, 1, 0, 1, 0); - $grid->GridSetField(1, $i, 1, ${$_->{real_w}}, 0, 0, 0, 0, 1, 0); - $i++; - if ($_->{extra_text}) { - $grid->GridSetField(0, $i, 1, ${Newt::Component::Label('')}, 0, 0, 1, 0, 1, 0); - $grid->GridSetField(1, $i, 1, ${$_->{extra_text}}, 0, 0, 0, 0, 1, 0); - $i++; - } - } - - my $listg = do { - my $wanted_header_height = min(8, listlength(messages($width, @messages))); - my $height_avail = $height - $wanted_header_height - 13; - #- use a scrolled window if there is a lot of checkboxes (aka - #- ask_many_from_list) or a lot of widgets in general (aka - #- options of a native PostScript printer in printerdrake) - #- !! works badly together with list's (lists are one widget, so a - #- big list window will not switch to scrollbar mode) :-( - if (@l > 3 && $total_size > $height_avail) { - $grid->GridPlace(1, 1); #- Uh?? otherwise the size allocated is bad - if ($has_scroll) { - #- trying again with no_individual_scroll set - $o->{no_individual_scroll} and internal_error('no_individual_scroll already set, argh...'); - $o->{no_individual_scroll} = 1; - goto &ask_fromW_real; #- same player shoot again! - } - $has_scroll = 1; - $total_size = $height_avail; - - my $scroll = Newt::Component::VerticalScrollbar($height_avail, 9, 10); # 9=NEWT_COLORSET_CHECKBOX, 10=NEWT_COLORSET_ACTCHECKBOX - my $subf = $scroll->Form('', 0); - $subf->FormSetHeight($height_avail); - $subf->FormAddGrid($grid, 0); - Newt::Grid::HCloseStacked3($subf, separator(1, $height_avail-1), $scroll); - } else { - $grid; - } - }; - - my ($ok, $cancel) = ($common->{ok}, $common->{cancel}); - $cancel = $::isWizard && !$::Wizard_no_previous ? N("Previous") : N("Cancel") if !defined $cancel && !defined $ok; - $ok ||= $::isWizard ? ($::Wizard_finished ? N("Finish") : N("Next")) : N("Ok"); - - my @okcancel = grep { $_ } $ok, $cancel; - @okcancel = reverse(@okcancel) if $::isWizard; - my @buttons_text = (if_(@$l2, $common->{advanced_state} ? $common->{advanced_label_close} : $common->{advanced_label}), @okcancel); - my ($buttonbar, @buttons) = Newt::Grid::ButtonBar(map { simplify_string($_) } @buttons_text); - my $advanced_button = @$l2 && shift @buttons; - @buttons = reverse(@buttons) if $::isWizard; - my ($ok_button, $cancel_button) = @buttons; - - my $form = Newt::Component::Form(\undef, '', 0); - my $window = Newt::Grid::GridBasicWindow(first(myTextbox(!$has_scroll, $height - $total_size, @messages)), $listg, $buttonbar); - $window->GridWrappedWindow($common->{title} || ''); - $form->FormAddGrid($window, 1); - - my $check = sub { - my ($f) = @_; - - my ($error, $_focus) = $f->(); - - if ($error) { - $set_all->(); - } - !$error; - }; - - my ($blocked, $canceled); - while (1) { - my $r = $form->RunForm; - - $get_all->(); - - if ($advanced_button && $$r == $$advanced_button) { - invbool(\$common->{advanced_state}); - $form->FormDestroy; - Newt::PopWindow(); - return &ask_fromW_real; - } - - $canceled = $cancel_button && $$r == $$cancel_button; - - next if !$canceled && any { ${$_->{invalid_choice}} } @widgets; - - $blocked = - $$r == $$ok_button && - $common->{callbacks}{ok_disabled} && - do { $common->{callbacks}{ok_disabled}() }; - - if (my $button = find { $$r == ${$_->{w}} } @widgets) { - my $v = $button->{e}{clicked_may_quit}(); - $form->FormDestroy; - Newt::PopWindow(); - return $v || &ask_fromW; - } - last if !$blocked && $check->($common->{callbacks}{$canceled ? 'canceled' : 'complete'}); - } - - $form->FormDestroy; - Newt::PopWindow(); - !$canceled; -} - - -sub waitbox { - my ($title, $messages) = @_; - my ($t, $w, $h) = myTextbox(1, $height, @$messages); - my $f = Newt::Component::Form(\undef, '', 0); - Newt::CenteredWindow($w, $h, $title); - $f->FormAddComponent($t); - $f->DrawForm; - Newt::Refresh(); - $f->FormDestroy; - push @wait_messages, $f; - $f; -} - - -sub wait_messageW { - my ($_o, $title, $messages) = @_; - { form => waitbox($title, $messages), title => $title }; -} - -sub wait_message_nextW { - my ($o, $messages, $w) = @_; - $o->wait_message_endW($w); - $o->wait_messageW($w->{title}, $messages); -} -sub wait_message_endW { - my ($_o, $_w) = @_; - my $_wait = pop @wait_messages; -# log::l("interactive_newt does not handle none stacked wait-messages") if $w->{form} != $wait; - Newt::PopWindow(); -} - -sub simplify_string { - my ($s, $o_width) = @_; - $s =~ s/\n/ /g; - $s = substr($s, 0, $o_width || 40); #- truncate if too long - $s; -} - -sub ok { - N("Ok"); -} - -sub cancel { - N("Cancel"); -} - -1; diff --git a/perl-install/interactive/stdio.pm b/perl-install/interactive/stdio.pm index 553f3fec5..5bc53a0f5 100644 --- a/perl-install/interactive/stdio.pm +++ b/perl-install/interactive/stdio.pm @@ -1,4 +1,4 @@ -package interactive::stdio; # $Id$ +package interactive::stdio; use diagnostics; use strict; @@ -63,14 +63,14 @@ ask_fromW_begin: my @labels; my $format_label = sub { my ($e) = @_; return sprintf("`%s' %s %s\n", ${$e->{val}}, $e->{label}, $e->{text}) }; my $do_widget = sub { - my ($e, $ind) = @_; + my ($e, $_ind) = @_; if ($e->{type} eq 'bool') { print "$e->{text} $e->{label}\n"; print N("Your choice? (0/1, default `%s') ", ${$e->{val}} || '0'); my $i = readln(); if ($i) { - to_bool($i) != to_bool(${$e->{val}}) and $common->{callbacks}{changed}->($ind); + to_bool($i) != to_bool(${$e->{val}}) && $e->{changed} and $e->{changed}->(); ${$e->{val}} = $i; } } elsif ($e->{type} =~ /list/) { @@ -89,12 +89,18 @@ ask_fromW_begin: print "\n"; my $i = good_choice(may_apply($e->{format}, ${$e->{val}}), $n); print "Setting to <", $i ? ${$e->{list}}[$i-1] : ${$e->{val}}, ">\n"; - $i and ${$e->{val}} = ${$e->{list}}[$i-1], $common->{callbacks}{changed}->($ind); + if ($i) { + ${$e->{val}} = ${$e->{list}}[$i-1]; + $e->{changed} and $e->{changed}->(); + } } elsif ($e->{type} eq 'button') { print N("Button `%s': %s", $e->{label}, may_apply($e->{format}, ${$e->{val}})), " $e->{text}\n"; print N("Do you want to click on this button?"); my $i = readln(); - $i && $i !~ /^n/i and $e->{clicked_may_quit}(), $common->{callbacks}{changed}->($ind); + if ($i && $i !~ /^n/i) { + $e->{clicked_may_quit}(); + $e->{changed} and $e->{changed}->(); + } } elsif ($e->{type} eq 'label') { my $t = $format_label->($e); push @labels, $t; @@ -106,7 +112,7 @@ ask_fromW_begin: ${$e->{val}} = $i || ${$e->{val}}; ${$e->{val}} = '' if ${$e->{val}} eq 'void'; print "Setting to <", ${$e->{val}}, ">\n"; - $i and $common->{callbacks}{changed}->($ind); + $i && $e->{changed} and $e->{changed}->(); } else { printf "UNSUPPORTED WIDGET TYPE (type <%s> label <%s> text <%s> val <%s>\n", $e->{type}, $e->{label}, $e->{text}, ${$e->{val}}; } @@ -153,28 +159,21 @@ Your choice? "); } else { $i = 1; } - my ($callback_error) = $common->{callbacks}{$i == 2 ? 'canceled' : 'complete'}->(); - $callback_error and goto ask_fromW_begin; + if ($i == 1 && !$common->{validate}()) { + goto ask_fromW_begin; + } return $i != 2; } sub wait_messageW { - my ($_o, $_title, $message) = @_; - print join "\n", @$message; + my ($_o, $_title, $message, $message_modifiable) = @_; + print join "\n", $message, $message_modifiable; } sub wait_message_nextW { - my $m = join "\n", @{$_[1]}; + my $m = $_[1]; print "\r$m", ' ' x (60 - length $m); } sub wait_message_endW { print "\nDone\n" } -sub ok { - N("Ok"); -} - -sub cancel { - N("Cancel"); -} - 1; |