package interactive_gtk; # $Id$
use diagnostics;
use strict;
use vars qw(@ISA);
@ISA = qw(interactive);
use interactive;
use common;
use my_gtk qw(:helpers :wrappers);
my $forgetTime = 1000; #- in milli-seconds
sub new {
($::windowheight, $::windowwidth) = my_gtk::gtkroot()->get_size if !$::isInstall;
goto &interactive::new;
}
sub enter_console { my ($o) = @_; $o->{suspended} = common::setVirtual(1) }
sub leave_console { my ($o) = @_; common::setVirtual(delete $o->{suspended}) }
sub exit {
gtkset_mousecursor_normal(); #- for restoring a normal in any case on standalone
my_gtk::flush();
$::isEmbedded and kill 10, $::CCPID; #10 is USR1
c::_exit($_[1]) #- workaround
}
sub ask_warn {
local $my_gtk::pop_it = 1;
&interactive::ask_warn;
}
sub ask_fileW {
my ($o, $title, $dir) = @_;
my $w = my_gtk->new($title);
$dir .= '/' if $dir !~ m|/$|;
my_gtk::_ask_file($w, $title, $dir);
$w->main;
}
sub create_boxradio {
my ($e, $may_go_to_next, $changed, $double_click) = @_;
my @l = map { may_apply($e->{format}, $_) } @{$e->{list}};
my $boxradio = gtkpack2__(new Gtk::VBox(0, 0),
my @radios = gtkradio('', @l));
$boxradio->show;
my $tips = new Gtk::Tooltips;
mapn {
my ($txt, $w) = @_;
$w->signal_connect(button_press_event => $double_click) if $double_click;
$w->signal_connect(key_press_event => sub {
my ($w, $event) = @_;
$may_go_to_next->($w, $event, 'tab');
1;
});
$w->signal_connect(clicked => sub {
${$e->{val}} = $txt;
&$changed;
});
if ($e->{help}) {
gtkset_tip($tips, $w,
ref($e->{help}) eq 'HASH' ? $e->{help}{$txt} :
ref($e->{help}) eq 'CODE' ? $e->{help}($txt) : $e->{help});
}
} $e->{list}, \@radios;
$boxradio, sub {
my ($v) = @_;
mapn { $_[0]->set_active($_[1] eq $v) } \@radios, $e->{list};
}, $radios[0];
}
sub create_clist {
my ($e, $may_go_to_next, $changed, $double_click) = @_;
my $curr;
my @l = map { may_apply($e->{format}, $_) } @{$e->{list}};
my $list = new Gtk::CList(1);
$list->set_selection_mode('browse');
$list->set_column_auto_resize(0, 1);
my $select = sub {
$list->set_focus_row($_[0]);
$list->select_row($_[0], 0);
$list->moveto($_[0], 0, 0.5, 0) if $list->row_is_visible($_[0]) ne 'full';
};
# ref $title && !@okcancel ?
# $list->signal_connect(button_release_event => $leave) :
# $list->signal_connect(button_press_event => sub { &$leave if $_[1]{type} =~ /^2/ });
my ($first_time, $starting_word, $start_reg) = (1, '', "^");
my $timeout;
$list->signal_connect(key_press_event => sub {
my ($w, $event) = @_;
my $c = chr($event->{keyval} & 0xff);
Gtk->timeout_remove($timeout) if $timeout; $timeout = '';
if ($event->{keyval} >= 0x100) {
&$may_go_to_next if $c eq "\r" || $c eq "\x8d";
$starting_word = '' if $event->{keyval} != 0xffe4; # control
} else {
if ($event->{state} & 4) {
#- control pressed
$c eq "s" or return 1;
$start_reg and $start_reg = '', return 1;
$curr++;
} else {
&$may_go_to_next if $c eq ' ';
$curr++ if $starting_word eq '' || $starting_word eq $c;
$starting_word .= $c unless $starting_word eq $c;
}
my $word = quotemeta $starting_word;
my $j; for ($j = 0; $j < @l; $j++) {
$l[($j + $curr) % @l] =~ /$start_reg$word/i and last;
}
$j == @l ?
$starting_word = '' :
$select->(($j + $curr) % @l);
$timeout = Gtk->timeout_add($forgetTime, sub { $timeout = $starting_word = ''; 0 } );
}
1;
});
$list->show;
$list->append($_) foreach @l;
$list->signal_connect(select_row => sub {
my ($w, $row) = @_;
${$e->{val}} = $e->{list}[$curr = $row];
&$changed;
});
$list->signal_connect(button_press_event => $double_click) if $double_click;
$list, sub {
my ($v) = @_;
eval {
my $nb = find_index { $_ eq $v } @{$e->{list}};
$select->($nb) if $nb != $list->focus_row;
};
};
}
sub create_ctree {
my ($e, $may_go_to_next, $changed, $double_click, $tree_expanded) = @_;
my @l = map { may_apply($e->{format}, $_) } @{$e->{list}};
my $sep = quotemeta $e->{separator};
my $tree = Gtk::CTree->new(1, 0);
my (%wtree, %wleaves, $size, $selected_via_click);
my $parent; $parent = sub {
if (my $w = $wtree{"$_[0]$e->{separator}"}) { return $w }
my $s;
foreach (split $sep, $_[0]) {
$wtree{"$s$_$e->{separator}"} ||=
$tree->insert_node($s ? $parent->($s) : undef, undef, [$_], 5, (undef) x 4, 0, $tree_expanded);
$size++ if !$s;
$s .= "$_$e->{separator}";
}
$wtree{$s};
};
foreach (@l) {
my ($root, $leaf) = /(.*)$sep(.+)/ ? ($1, $2) : ('', $_);
$wleaves{$_} = $tree->insert_node($parent->($root), undef, [$leaf], 5, (undef) x 4, 1, 0);
}
undef %wtree;
my $select = sub {
my ($node) = @_;
for (my $c = $node; $c; $c = $c->row->parent) {
$tree->expand($c);
}
for (my $i = 0; $tree->node_nth($i); $i++) {
if ($tree->node_nth($i) == $node) {
$tree->set_focus_row($i);
last;
}
}
$tree->select($node);
$tree->node_moveto($node, 0, 0.5, 0) if $tree->node_is_visible($node) ne 'full';
};
my $curr = $tree->node_nth(0); #- default value
$tree->set_column_auto_resize(0, 1);
$tree->set_selection_mode('browse');
$tree->set_row_height($tree->style->font->ascent + $tree->style->font->descent + 1);
$tree->signal_connect(tree_select_row => sub {
$curr = $_[1];
if ($curr->row->is_leaf) {
my @ll; for (my $c = $curr; $c; $c = $c->row->parent) {
unshift @ll, first $tree->node_get_pixtext($c, 0);
}
my $val = join $e->{separator}, @ll;
mapn {
${$e->{val}} = $_[1] if $val eq $_[0]
} \@l, $e->{list};
&$changed;
} else {
$tree->expand($curr) if $selected_via_click;
}
});
my ($first_time, $starting_word, $start_reg) = (1, '', "^");
my $timeout;
my $toggle = sub {
$curr->row->is_leaf ?
&$may_go_to_next :
$tree->toggle_expansion($curr);
};
$tree->signal_connect(key_press_event => sub {
my ($w, $event) = @_;
$selected_via_click = 0;
my $c = chr($event->{keyval} & 0xff);
$curr or return;
Gtk->timeout_remove($timeout) if $timeout; $timeout = '';
if ($event->{keyval} >= 0x100) {
&$toggle if $c eq "\r" || $c eq "\x8d";
$starting_word = '' if $event->{keyval} != 0xffe4; # control
} else {
my $next;
if ($event->{state} & 4) {
#- control pressed
$c eq "s" or return 1;
$start_reg and $start_reg = '', return 1;
$next = 1;
} else {
&$toggle if $c eq ' ';
$next = 1 if $starting_word eq '' || $starting_word eq $c;
$starting_word .= $c unless $starting_word eq $c;
}
my $word = quotemeta $starting_word;
my ($after, $best);
$tree->pre_recursive(undef, sub {
my ($tree, $node) = @_;
$next &&= !$after;
$after ||= $node == $curr;
my ($t) = $tree->node_get_pixtext($node, 0);
if ($t =~ /$start_reg$word/i) {
if ($after && !$next) {
($best, $after) = ($node, 0);
} else {
$best ||= $node;
}
}
});
if (defined $best) {
$select->($best);
} else {
$starting_word = '';
}
$timeout = Gtk->timeout_add($forgetTime, sub { $timeout = $starting_word = ''; 0 });
}
1;
});
$tree->signal_connect(button_press_event => sub {
$selected_via_click = 1;
&$double_click if $curr->row->is_leaf && $double_click;
});
$tree, sub {
my $v = may_apply($e->{format}, $_[0]);
$select->($wleaves{$v} || return) if $wleaves{$v} != $tree->selection;
}, $size;
}
sub create_list {
my ($e, $may_go_to_next, $changed, $double_click) = @_;
my $l = $e->{list};
my $list = new Gtk::List();
$list->set_selection_mode('browse');
my $select = sub {
$list->select_item($_[0]);
};
my $tips = new Gtk::Tooltips;
my $toselect;
map_index {
my $item = new Gtk::ListItem(may_apply($e->{format}, $_));
$item->signal_connect(key_press_event => sub {
my ($w, $event) = @_;
my $c = chr($event->{keyval} & 0xff);
$may_go_to_next->($event) if $event->{keyval} < 0x100 ? $c eq ' ' : $c eq "\r" || $c eq "\x8d";
1;
});
$list->append_items($item);
$item->show;
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;
#- 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;
$list, sub {
my ($v) = @_;
eval {
$select->(find_index { $_ eq $v } @$l);
};
};
}
sub ask_fromW {
my ($o, $common, $l, $l2) = @_;
my $ignore = 0; #-to handle recursivity
my $mainw = my_gtk->new($common->{title}, %$o);
$mainw->sync; # for XPM's creation
#-the widgets
my (@widgets, @widgets_always, @widgets_advanced, $advanced, $advanced_pack, $has_horiz_scroll, $has_scroll, $total_size, $max_width);
my $tooltips = new Gtk::Tooltips;
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;
$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->();
$set_all->();
};
my $create_widget = sub {
my ($e, $ind) = @_;
my $may_go_to_next = sub {
my ($w, $event, $kind) = @_;
if ($kind eq 'tab') {
if (($event->{keyval} & 0x7f) == 0x9) {
$w->signal_emit_stop("key_press_event");
if ($ind == $#widgets) {
$mainw->{ok}->grab_focus;
} else {
$widgets[$ind+1]{focus_w}->grab_focus;
}
}
} else {
if (!$event || ($event->{keyval} & 0x7f) == 0xd) {
$w->signal_emit_stop("key_press_event") if $event;
if ($ind == $#widgets) {
@widgets == 1 ? $mainw->{ok}->clicked : $mainw->{ok}->grab_focus;
} else {
$widgets[$ind+1]{focus_w}->grab_focus;
}
}
}
};
my $changed = sub { $update->(sub { $common->{callbacks}{changed}($ind) }) };
my ($w, $real_w, $focus_w, $set, $get, $expand, $size, $width);
if ($e->{type} eq 'iconlist') {
$w = new Gtk::Button;
$set = sub {
gtkdestroy($e->{icon});
my $f = $e->{icon2f}->($_[0]);
$e->{icon} = -e $f ?
gtkpng($f) :
new Gtk::Label(may_apply($e->{format}, $_[0]));
$w->add($e->{icon});
$e->{icon}->show;
};
$w->signal_connect(clicked => sub {
$set->(${$e->{val}} = next_val_in_array(${$e->{val}}, $e->{list}));
$changed->();
});
$real_w = gtkpack_(new Gtk::HBox(0,10), 1, new Gtk::HBox(0,0), 0, $w, 1, new Gtk::HBox(0,0), );
} elsif ($e->{type} eq 'bool') {
$w = Gtk::CheckButton->new($e->{text});
$w->signal_connect(clicked => $changed);
$set = sub { $w->set_active($_[0]) };
$get = sub { $w->get_active };
$width = length $e->{text};
} elsif ($e->{type} eq 'label') {
$w = Gtk::Label->new(${$e->{val}});
$set = sub { $w->set($_[0]) };
$width = length ${$e->{val}};
} elsif ($e->{type} eq 'button') {
$w = Gtk::Button->new('');
$w->signal_connect(clicked => sub {
$get_all->();
if ($::isWizard) {
$mainw->{rwindow}->set_sensitive(0);
} else {
$mainw->{rwindow}->hide;
}
if (my $v = $e->{clicked_may_quit}()) {
$mainw->{retval} = $v;
Gtk->main_quit;
}
if ($::isWizard) {
$mainw->{rwindow}->set_sensitive(1);
} else {
$mainw->{rwindow}->show;
}
$set_all->();
});
$set = sub { $w->child->set(may_apply($e->{format}, $_[0])) };
$width = length may_apply($e->{format}, ${$e->{val}});
} elsif ($e->{type} eq 'range') {
my $adj = create_adjustment(${$e->{val}}, $e->{min}, $e->{max});
$adj->signal_connect(value_changed => $changed);
$w = new Gtk::HScale($adj);
$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 };
$size = 2;
} elsif ($e->{type} =~ /list/) {
my $quit_if_double_click =
#- i'm the only one, double click means accepting
@$l == 1 || $e->{quit_if_double_click} ?
sub { if ($_[1]{type} =~ /^2/) { $mainw->{retval} = 1; Gtk->main_quit } } : '';
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;
if ($e->{help}) {
#- used only when needed, as key bindings are dropped by List (CList 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, $size) = create_ctree(@para, $e->{tree_expanded});
} else {
($w, $set, $focus_w) = $use_boxradio ? create_boxradio(@para) : create_clist(@para);
}
if (@{$e->{list}} > (@$l == 1 ? 10 : 4)) {
$has_scroll = 1;
$expand = 1;
$real_w = createScrolledWindow($w);
$size = (@$l == 1 ? 10 : 4);
} else {
$size ||= @{$e->{list}};
}
$width = max(map { length } @{$e->{list}});
} else {
if ($e->{type} eq "combo") {
$w = new Gtk::Combo;
$w->set_use_arrows_always(1);
$w->entry->set_editable(!$e->{not_edit});
$w->set_popdown_strings(@{$e->{list}});
$w->disable_activate;
($real_w, $w) = ($w, $w->entry);
my @l = sort { $b <=> $a } map { length } @{$e->{list}};
$has_horiz_scroll = 1;
$width = $l[@l / 16]; # take the third octile (think quartile)
} else {
$w = new Gtk::Entry;
$w->signal_connect(focus_in_event => sub { $w->select_region });
$w->signal_connect(focus_out_event => sub { $w->select_region(0,0) });
}
$w->signal_connect(key_press_event => $may_go_to_next);
$w->signal_connect(changed => $changed);
$w->set_visibility(0) if $e->{hidden};
$set = sub { $w->set_text($_[0]) if $_[0] ne $w->get_text };
$get = sub { $w->get_text };
}
$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});
$max_width = max($max_width, $width);
$total_size += $size || 1;
{ e => $e, w => $w, real_w => $real_w || $w, focus_w => $focus_w || $w, expand => $expand,
get => $get || sub { ${$e->{val}} }, set => $set || sub {},
icon_w => -e $e->{icon} ? gtkpng($e->{icon}) : '' };
};
@widgets_always = map_index { $create_widget->($_, $::i ) } @$l;
my $always_total_size = $total_size;
@widgets_advanced = map_index { $create_widget->($_, $::i + @$l) } @$l2;
my $advanced_total_size = $total_size - $always_total_size;
my $pack = create_box_with_title($mainw, @{$common->{messages}});
my ($totalheight, $totalwidth) = ($mainw->{box_size}, 0);
my $set_default_size = sub {
if (!$::isEmbedded && !$::isWizard || $my_gtk::pop_it) {
if ($has_scroll || $has_horiz_scroll) {
$mainw->{rwindow}->set_default_size($totalwidth+6+$my_gtk::shape_width, $has_scroll ? $totalheight+6+3+$my_gtk::shape_width : 0);
}
}
};
my $set_advanced = sub {
($advanced) = @_;
$set_default_size->() if $advanced;
$advanced ? $advanced_pack->show : $advanced_pack->hide;
@widgets = (@widgets_always, $advanced ? @widgets_advanced : ());
$mainw->sync; #- for $set_all below (mainly for the set of clist)
$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($advanced ? $common->{advanced_label_close} : $common->{advanced_label});
} ];
my $create_widgets = sub {
my ($size, @widgets) = @_;
my $w = create_packtable({}, map { [($_->{icon_w}, $_->{e}{label}, $_->{real_w})]} @widgets);
$size && $total_size or return $w; #- do not bother computing stupid/bad things
my $ratio = max($size / $total_size, 0.2);
my ($possibleheight, $possiblewidth) = $::isEmbedded && !$my_gtk::pop_it ? (450, 380) : ($::windowheight * 0.8, $::windowwidth * 0.8);
$possibleheight -= $mainw->{box_size};
my $wantedwidth = max(250, $max_width * 5);
my $width = min($possiblewidth, $wantedwidth);
my $wantedheight = my_gtk::n_line_size($size, 'various', $mainw->{rwindow});
my $height = min($possibleheight * $ratio, max(200, $wantedheight));
$totalheight += $height;
$totalwidth = max($width, $totalwidth);
my $has = $wantedwidth > $width || $wantedheight > $height;
$has_scroll ||= $has;
$has ? createScrolledWindow($w) : $w;
};
gtkpack_($pack,
1, $create_widgets->($always_total_size, @widgets_always),
if_($common->{ok} || $::isWizard,
0, $mainw->create_okcancel($common->{ok}, $common->{cancel}, '', if_(@$l2, $advanced_button))));
my $has_scroll_always = $has_scroll;
my @adv = map { warp_text($_) } @{$common->{advanced_messages}};
$advanced_pack =
gtkpack_(new Gtk::VBox(0,0),
0, '',
(map {; 0, new Gtk::Label($_) } @adv),
0, new Gtk::HSeparator,
1, $create_widgets->($advanced_total_size, @widgets_advanced));
$pack->pack_start($advanced_pack, 1, 1, 0);
gtkadd($mainw->{window}, $pack);
$set_default_size->() if $has_scroll_always;
$set_advanced->(0);
(@widgets ? $widgets[0]{focus_w} : $common->{focus_cancel} ? $mainw->{cancel} : $mainw->{ok})->grab_focus();
my $check = sub {
my ($f) = @_;
sub {
$get_all->();
my ($error, $focus) = $f->();
if ($error) {
$set_all->();
$widgets[$focus || 0]{focus_w}->grab_focus();
}
!$error;
}
};
$mainw->main(map { $check->($common->{callbacks}{$_}) } 'complete', 'canceled');
}
sub ask_browse_tree_info_refW {
my ($o, $common) = @_;
my ($curr, $parent, $info_widget, $w_size, $prev_label, $go, $idle);
my (%wtree, %ptree, %pix);
my $w = my_gtk->new($common->{title});
my $details = new Gtk::VBox(0,0);
my $tree = Gtk::CTree->new(3, 0);
$tree->set_selection_mode('browse');
$tree->set_column_width(0, 200);
$tree->set_column_auto_resize($_, 1) foreach 1..2;
gtkadd($w->{window},
gtkpack_(new Gtk::VBox(0,5),
0, $common->{message},
1, gtkpack(new Gtk::HBox(0,0),
createScrolledWindow($tree),
gtkadd(gtkset_usize(new Gtk::Frame(_("Info")), $::windowwidth - 490, 0),
createScrolledWindow($info_widget = new Gtk::Text),
)),
0, my $l = new Gtk::HBox(0,15),
0, gtkpack(new Gtk::HBox(0,10),
$go = gtksignal_connect(new Gtk::Button($common->{ok}), "clicked" => sub { $w->{retval} = 1; Gtk->main_quit }),
$common->{cancel} ? (gtksignal_connect(new Gtk::Button($common->{cancel}), "clicked" => sub { $w->{retval} = 0; Gtk->main_quit })) : (),
)
));
gtkpack__($l, my $toolbar = new Gtk::Toolbar('horizontal', 'icons'));
if ($common->{auto_deps}) {
gtkpack__($l, gtksignal_connect(gtkset_active(new Gtk::CheckButton($common->{auto_deps}), $common->{state}{auto_deps}), clicked => sub { invbool \$common->{state}{auto_deps} }));
}
$l->pack_end($w_size = new Gtk::Label($prev_label = $common->{state}{status_label}), 0, 1, 20);
$w->{window}->set_usize(map { $_ - 2 * $my_gtk::border - 4 } $::windowwidth, $::windowheight);
$go->grab_focus;
$w->{rwindow}->show_all;
my $update_size = sub {
my $new_label = $common->{get_status}();
$prev_label ne $new_label and $w_size->set($prev_label = $new_label);
};
my $set_node_state_flat = sub {
my ($node, $state) = @_;
unless ($pix{$state}) {
foreach ("$ENV{SHARE_PATH}/$state.png", "$ENV{SHARE_PATH}/rpm-$state.png") {
if (-e $_) {
$pix{$state} = [ gtkcreate_png($_) ];
last;
}
}
$pix{$state} or die "unable to find a pixmap for state $state";
}
$tree->node_set_pixmap($node, 1, $pix{$state}[0], $pix{$state}[1]);
};
my $set_node_state_tree; $set_node_state_tree = sub {
my ($node, $state) = @_;
unless ($pix{$state}) {
foreach ("$ENV{SHARE_PATH}/$state.png", "$ENV{SHARE_PATH}/rpm-$state.png") {
if (-e $_) {
$pix{$state} = [ gtkcreate_png($_) ];
last;
}
}
$pix{$state} or die "unable to find a pixmap for state $state";
}
if ($node->{state} ne $state) {
if ($node->row->is_leaf) {
my $parent = $node->row->parent;
my $stats = $parent->{state_stats} ||= {}; --$stats->{$node->{state}}; ++$stats->{$state};
my @list = grep { $stats->{$_} > 0 } keys %$stats;
my $new_state = @list == 1 ? $list[0] : 'semiselected';
$parent->{state} ne $new_state and $set_node_state_tree->($parent, $new_state);
}
$tree->node_set_pixmap($node, 1, $pix{$state}[0], $pix{$state}[1]);
$node->{state} = $state; #- hack to to get this features efficiently.
}
};
my $set_node_state = $common->{state}{flat} ? $set_node_state_flat : $set_node_state_tree;
my $set_leaf_state = sub {
my ($leaf, $state) = @_;
$set_node_state->($_, $state) foreach @{$ptree{$leaf}};
};
my $add_parent; $add_parent = sub {
my ($root, $state) = @_;
$root or return undef;
if (my $w = $wtree{$root}) { return $w }
my $s; foreach (split '\|', $root) {
my $s2 = $s ? "$s|$_" : $_;
$wtree{$s2} ||= do {
my $n = $tree->insert_node($s ? $add_parent->($s, $state) : undef, undef, [$_, '', ''], 5, (undef) x 4, 0, 0);
$n;
};
$s = $s2;
}
$set_node_state->($wtree{$s}, $state); #- use this state by default as tree is building.
$wtree{$s};
};
my $add_node = sub {
my ($leaf, $root) = @_;
my $state = $common->{node_state}($leaf) or return;
my $node = $tree->insert_node($add_parent->($root, $state), undef, [$leaf, '', ''], 5, (undef) x 4, 1, 0);
$set_node_state->($node, $state);
push @{$ptree{$leaf}}, $node;
};
my $add_nodes = sub {
foreach (values %ptree) {
delete $_->{state} foreach @$_;
}
foreach (values %wtree) {
delete $_->{state};
delete $_->{state_stats};
}
%ptree = %wtree = ();
$tree->freeze;
while (1) { $tree->remove_node($tree->node_nth(0) || last) }
$common->{state}{flat} = $_[0];
$set_node_state = $common->{state}{flat} ? $set_node_state_flat : $set_node_state_tree;
$common->{build_tree}($add_node, $common->{state}{flat});
$tree->thaw;
&$update_size;
};
$add_nodes->($common->{state}{flat});
my @toolbar = (ftout => [ _("Expand Tree") , sub { $tree->expand_recursive(undef) } ],
ftin => [ _("Collapse Tree") , sub { $tree->collapse_recursive(undef) } ],
reload => [ _("Toggle between flat and group sorted"), sub { $add_nodes->(!$common->{state}{flat}) } ]);
foreach my $ic (@{$common->{icons} || []}) {
push @toolbar, ( $ic->{icon} => [ $ic->{help}, sub {
if ($ic->{code}) {
my $w = $ic->{wait_message} && $o->wait_message('', $ic->{wait_message});
$ic->{code}();
$add_nodes->($common->{state}{flat});
}
} ]);
}
my %toolbar = @toolbar;
$toolbar->set_button_relief("none");
foreach (grep_index { $::i % 2 == 0 } @toolbar) {
gtksignal_connect($toolbar->append_item(undef, $toolbar{$_}[0], undef, gtkpng("$ENV{SHARE_PATH}/$_.png")),
clicked => $toolbar{$_}[1]);
}
$toolbar->set_style("icons");
my $display_info = sub { gtktext_insert($info_widget, $common->{get_info}($curr)); 0 };
my $children = sub { map { ($tree->node_get_pixtext($_, 0))[0] } gtkctree_children($_[0]) };
my $toggle = sub {
if (ref $curr && ! $_[0]) {
$tree->toggle_expansion($curr);
} else {
if (ref $curr) {
my @l = $common->{grep_allowed_to_toggle}($children->($curr)) or return;
my @unsel = $common->{grep_unselected}(@l);
my @p = @unsel ?
@unsel : # not all is selected, select all
@l;
$common->{toggle_nodes}($set_leaf_state, @p);
&$update_size;
$parent = $curr;
} else {
$common->{check_interactive_to_toggle}($curr) and $common->{toggle_nodes}($set_leaf_state, $curr);
&$update_size;
}
}
};
$tree->signal_connect(key_press_event => sub {
my ($w, $e) = @_;
my $c = chr($e->{keyval} & 0xff);
$toggle->(0) if $e->{keyval} >= 0x100 ? $c eq "\r" || $c eq "\x8d" : $c eq ' ';
1;
});
$tree->signal_connect(tree_select_row => sub {
Gtk->timeout_remove($idle) if $idle;
if ($_[1]->row->is_leaf) {
($curr) = $tree->node_get_pixtext($_[1], 0);
$parent = $_[1]->row->parent;
$idle = Gtk->timeout_add(100, $display_info);
} else {
$curr = $_[1];
}
$toggle->(1) if $_[2] == 1;
});
&$update_size;
my $b = before_leaving { #- ensure cleaning here.
foreach (values %ptree) {
delete $_->{state} foreach @$_;
}
foreach (values %wtree) {
delete $_->{state};
delete $_->{state_stats};
}
};
$w->main;
}
sub wait_messageW($$$) {
my ($o, $title, $messages) = @_;
local $my_gtk::pop_it = 1;
my $w = my_gtk->new($title, %$o, grab => 1);
gtkadd($w->{window}, my $hbox = new Gtk::HBox(0,0));
$hbox->pack_start(my $box = new Gtk::VBox(0,0), 1, 1, 10);
$box->pack_start($_, 1, 1, 4) foreach my @l = map { new Gtk::Label(join("\n", warp_text($_))) } @$messages;
($w->{wait_messageW} = $l[$#l])->signal_connect(expose_event => sub { $w->{displayed} = 1 });
$w->{rwindow}->set_position('center') if ($::isStandalone && (!$::isEmbedded && !$::isWizard || $my_gtk::pop_it));
$w->{window}->show_all;
$w->sync until $w->{displayed};
$w;
}
sub wait_message_nextW {
my ($o, $messages, $w) = @_;
my $msg = join("\n", warp_text(join "\n", @$messages));
return if $msg eq $w->{wait_messageW}->get; #- needed otherwise no expose_event :(
$w->{displayed} = 0;
$w->{wait_messageW}->set($msg);
$w->flush until $w->{displayed};
}
sub wait_message_endW {
my ($o, $w) = @_;
$w->destroy;
}
sub kill {
my ($o) = @_;
$o->{before_killing} ||= 0;
while (my $e = shift @tempory::objects) { $e->destroy }
while (@interactive::objects > $o->{before_killing}) {
my $w = pop @interactive::objects;
$w->destroy;
}
$o->{before_killing} = @interactive::objects;
}
1;
='n600' href='#n600'>600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
package install::steps_gtk; # $Id: steps_gtk.pm 266069 2010-02-09 19:47:35Z pterjan $
use diagnostics;
use strict;
use feature 'state';
use vars qw(@ISA);
@ISA = qw(install::steps_interactive interactive::gtk);
#-######################################################################################
#- misc imports
#-######################################################################################
use install::pkgs;
use install::steps_interactive;
use interactive::gtk;
use xf86misc::main;
use common;
use mygtk2;
use ugtk2 qw(:helpers :wrappers :create);
use devices;
use modules;
use install::gtk;
use install::any;
use mouse;
use install::help::help;
use log;
#-######################################################################################
#- In/Out Steps Functions
#-######################################################################################
sub new($$) {
my ($type, $o) = @_;
$ENV{DISPLAY} ||= $o->{display} || ":0";
my $wanted_DISPLAY = $::testing && -x '/usr/bin/Xnest' ? ':9' : $ENV{DISPLAY};
if (!$::local_install &&
($::testing ? $ENV{DISPLAY} ne $wanted_DISPLAY : $ENV{DISPLAY} =~ /^:\d/)) { #- is the display local or distant?
_setup_and_start_X($o, $wanted_DISPLAY) or return;
}
$ENV{DISPLAY} = $wanted_DISPLAY;
require detect_devices;
if (detect_devices::is_xbox()) {
modules::load('xpad');
run_program::run('xset', 'm', '1/8', '1');
}
any::disable_x_screensaver();
run_program::raw({ detach => 1 }, 'drakx-matchbox-window-manager');
install::gtk::init_gtk($o);
install::gtk::init_sizes($o);
install::gtk::install_theme($o);
install::gtk::create_steps_window($o);
_may_configure_framebuffer_640x480($o);
$ugtk2::grab = 1;
$o = (bless {}, ref($type) || $type)->SUPER::new($o);
$o->interactive::gtk::new;
$o;
}
sub _setup_and_start_X {
my ($o, $wanted_DISPLAY) = @_;
my $f = "/tmp/Xconf";
#- /tmp is mostly tmpfs, but not fully, since it doesn't allow: mount --bind /tmp/.X11-unix /mnt/tmp/.X11-unix
mkdir '/tmp/.X11-unix';
run_program::run('mount', '-t', 'tmpfs', 'none', '/tmp/.X11-unix');
my @servers = qw(Driver:fbdev Driver:vesa); #-)
if ($::testing) {
@servers = 'Xnest';
} elsif (arch() =~ /ia64/) {
require Xconfig::card;
my ($card) = Xconfig::card::probe();
@servers = map { if_($_, "Driver:$_") } $card && $card->{Driver}, 'fbdev';
} elsif (arch() =~ /i.86/) {
require Xconfig::card;
my ($card) = Xconfig::card::probe();
if ($card && $card->{card_name} eq 'i810') {
# early i810 do not support VESA:
log::l("graphical installer not supported on early i810");
undef @servers;
}
}
foreach (@servers) {
log::l("Trying with server $_");
my ($prog, $Driver) = /Driver:(.*)/ ? ('Xorg', $1) : /Xsun|Xnest|^X_move$/ ? $_ : "XF86_$_";
if (/FB/i) {
!$o->{vga16} && $o->{allowFB} or next;
$o->{allowFB} = _launchX($o, $f, $prog, $Driver, $wanted_DISPLAY) #- keep in mind FB is used.
and return 1;
} else {
$o->{vga16} = 1 if /VGA16/;
_launchX($o, $f, $prog, $Driver, $wanted_DISPLAY) and return 1;
}
}
return undef;
}
sub _launchX {
my ($o, $f, $server, $Driver, $wanted_DISPLAY) = @_;
mkdir '/var/log' if !-d '/var/log';
my @options = $wanted_DISPLAY;
if ($server eq 'Xnest') {
push @options, '-ac', '-geometry', $o->{vga} || ($o->{vga16} ? '640x480' : '800x600');
} else {
install::gtk::createXconf($f, @{$o->{mouse}}{'Protocol', 'device'}, $o->{mouse}{wacom}[0], $Driver);
push @options, '-allowMouseOpenFail', '-xf86config', $f if arch() !~ /^sparc/;
push @options, 'vt7', '-dpi', '75';
push @options, '-nolisten', 'tcp';
#- old weird servers: Xsun
push @options, '-fp', '/usr/share/fonts:unscaled' if $server =~ /Xsun/;
}
if (!fork()) {
c::setsid();
exec $server, @options or c::_exit(1);
}
#- wait for the server to start
foreach (1..5) {
sleep 1;
last if fuzzy_pidofs(qr/\b$server\b/);
log::l("$server still not running, trying again");
}
my $nb;
my $start_time = time();
foreach (1..60) {
log::l("waiting for the server to start ($_ $nb)");
log::l("Server died"), return 0 if !fuzzy_pidofs(qr/\b$server\b/);
$nb++ if xf86misc::main::Xtest($wanted_DISPLAY);
if ($nb > 2) { #- one succeeded test is not enough :-(
log::l("AFAIK X server is up");
return 1;
}
time() - $start_time < 60 or last;
time() - $start_time > 8 and print N("Xorg server is slow to start. Please wait..."), "\n";
sleep 1;
}
log::l("Timeout!!");
0;
}
#- if we success to start X in 640x480 using driver "vesa",
#- we configure to use fb on installed system (to ensure splashy works)
#- (useful on 800x480 netbooks)
sub _may_configure_framebuffer_640x480 {
my ($o) = @_;
if ($::rootwidth == 640 && !$o->{allowFB}) {
$o->{vga} = 785;
$o->{allowFB} = 1;
}
}
sub enteringStep {
my ($o, $step) = @_;
printf "Entering step `%s'\n", common::remove_translate_context($o->{steps}{$step}{text});
if (my $banner_title = $o->{steps}{$step}{banner_title}) {
set_default_step_items($banner_title);
}
$o->SUPER::enteringStep($step);
install::gtk::update_steps_position($o);
}
sub leavingStep {
my ($o, $step) = @_;
$o->SUPER::leavingStep($step);
}
sub charsetChanged {
my ($o) = @_;
Gtk2->set_locale;
install::gtk::load_font($o);
install::gtk::create_steps_window($o);
}
sub interactive_help_has_id {
my ($_o, $id) = @_;
exists $install::help::help::{$id};
}
sub interactive_help_get_id {
my ($_o, @l) = @_;
@l = map {
join("\n\n", map { s/\n/ /mg; $_ } split("\n\n", translate($install::help::help::{$_}->())));
} grep { exists $install::help::help::{$_} } @l;
join("\n\n\n", @l);
}
#-######################################################################################
#- Steps Functions
#-######################################################################################
sub selectLanguage {
my ($o) = @_;
$o->SUPER::selectLanguage;
$o->ask_warn('',
formatAlaTeX(N("Your system is low on resources. You may have some problem installing
%s. If that occurs, you can try a text install instead. For this,
press `F1' when booting on CDROM, then enter `text'.", N("Mageia")))) if availableRamMB() < 70; # 70MB
}
#------------------------------------------------------------------------------
sub selectMouse {
my ($o, $force) = @_;
my %old = %{$o->{mouse}};
$o->SUPER::selectMouse($force) or return;
my $mouse = $o->{mouse};
$mouse->{type} eq 'none' ||
$old{type} eq $mouse->{type} &&
$old{name} eq $mouse->{name} &&
$old{device} eq $mouse->{device} and return;
while (1) {
my $x_protocol_changed = mouse::change_mouse_live($mouse, \%old);
mouse::test_mouse_install($mouse, $x_protocol_changed) and return;
%old = %$mouse;
$o->SUPER::selectMouse;
$mouse = $o->{mouse};
}
}
sub setPackages {
my ($o) = @_;
my (undef, $old_title) = get_default_step_items();
set_default_step_items(N("Media Selection") || $old_title);
install::any::setPackages($o);
set_default_step_items($old_title);
}
sub reallyChooseDesktop {
my ($o, $title, $message, $choices, $choice) = @_;
my $w = ugtk2->new($title);
my %tips = (
KDE => N("Install %s KDE Desktop", N("Mageia")),
GNOME => N("Install %s GNOME Desktop", N("Mageia")),
Custom => N("Custom install"),
);
my $prev;
my @l = map {
my $val = $_;
$prev = gtknew('RadioButton', child =>
gtknew('Label', text => $val->[1]),
tip => $tips{$val->[0]},
toggled => sub { $choice = $val if $_[0]->get_active },
active => $choice == $val,
$prev ? (group => $prev->get_group) : ());
$prev->signal_connect(key_press_event => sub {
my (undef, $event) = @_;
if (!$event || ($event->keyval & 0x7f) == 0xd) {
Gtk2->main_quit;
}
});
my $img = gtksignal_connect(
gtkadd(Gtk2::EventBox->new, gtknew('Image', file => "desktop-$val->[0]")),
'button-press-event' => sub {
my %title = (
KDE => N("KDE Desktop"),
GNOME => N("GNOME Desktop"),
Custom => N("Custom Desktop"),
);
my $wp = ugtk2->new($title{$val->[0]}, transient => $w->{real_window}, modal => 1);
gtkadd($wp->{rwindow},
gtkpack_(Gtk2::VBox->new,
0, gtknew('Title2', label => N("Here's a preview of the '%s' desktop.", $val->[1]),
# workaround infamous 6 years old gnome bug #101968:
width => mygtk2::get_label_width(),
),
1, gtknew('Image', file => "desktop-$val->[0]-big"),
0, Gtk2::HSeparator->new,
0, gtkpack(create_hbox('end'),
gtknew('Button', text => N("Close"), clicked => sub { Gtk2->main_quit })
),
),
);
$wp->{real_window}->set_size_request(-1, -1);
$wp->{real_window}->grab_focus;
$wp->{real_window}->show_all;
$wp->main;
});
gtknew('VBox', border_width => 15, spacing => 10, children_tight => [
$img,
$prev,
]);
} @$choices;
ugtk2::gtkadd($w->{window},
gtknew('VBox', children => [
0, gtknew('Title2',
# workaround infamous 6 years old gnome bug #101968:
width => mygtk2::get_label_width(), label => $message . ' ' .
N("Click on images in order to see a bigger preview")),
1, gtknew('HButtonBox', children_loose => \@l),
0, $w->create_okcancel(N("Next"), undef, '',
[ gtknew('Install_Button', text => N("Help"),
clicked => sub {
interactive::gtk::display_help($o, { interactive_help_id => 'chooseDesktop' });
}), undef, 1 ])
]));
$w->main;
$choice;
}
sub reallyChooseGroups {
my ($o, $size_to_display, $individual, $_compssUsers) = @_;
my $w = ugtk2->new(N("Package Group Selection"));
my $w_size = gtknew('Label_Left', text => &$size_to_display, padding => [ 0, 0 ]);
my @entries;
my $entry = sub {
my ($e) = @_;
my $w = gtknew('CheckButton',
text => translate($e->{label}),
tip => translate($e->{descr}),
active_ref => \$e->{selected},
toggled => sub {
gtkset($w_size, text => &$size_to_display);
});
push @entries, $w;
$w;
};
#- when restarting this step, it might be necessary to reload the compssUsers.pl (bug 11558). kludgy.
if (!ref $o->{gtk_display_compssUsers}) { install::any::load_rate_files($o) }
ugtk2::gtkadd($w->{window},
gtknew('ScrolledWindow', child =>
gtknew('VBox', children => [
1, $o->{gtk_display_compssUsers}->($entry),
1, '',
if_($individual,
0, gtknew('CheckButton', text => N("Individual package selection"), active_ref => $individual),
),
0, $w_size,
0, Gtk2::HSeparator->new,
0, gtknew('HButtonBox', layout => 'edge', children_tight => [
gtknew('Install_Button', text => N("Help"), clicked => sub {
interactive::gtk::display_help($o, { interactive_help_id => 'choosePackageGroups' }) }),
gtknew('Button', text => N("Unselect All"), clicked => sub { $_->set_active(0) foreach @entries }),
gtknew('Button', text => N("Next"), clicked => sub { Gtk2->main_quit }),
]),
]),
)
);
$w->main;
1;
}
sub choosePackagesTree {
my ($o, $packages) = @_;
my $available = install::any::getAvailableSpace($o);
my $availableCorrected = install::pkgs::invCorrectSize($available / sqr(1024)) * sqr(1024);
my $common;
$common = { get_status => sub {
my $size = install::pkgs::selectedSize($packages);
N("Total size: %d / %d MB", install::pkgs::correctSize($size / sqr(1024)), $available / sqr(1024));
},
node_state => sub {
my $p = install::pkgs::packageByName($packages, $_[0]) or return;
!install::pkgs::packageMedium($packages, $p)->{ignore} or return;
$p->arch eq 'src' and return;
$p->flag_base and return 'base';
$p->flag_installed && !$p->flag_upgrade and return 'installed';
$p->flag_selected and return 'selected';
return 'unselected';
},
build_tree => sub {
my ($add_node, $flat) = @_;
if ($flat) {
foreach (sort map { $_->name }
grep { $_ && $_->arch ne 'src' }
@{$packages->{depslist}}) {
$add_node->($_, undef);
}
} else {
foreach my $root (@{$o->{compssUsers}}) {
my (@firstchoice, @others);
my %fl = map { ("CAT_$_" => 1) } @{$root->{flags}};
foreach my $p (@{$packages->{depslist}}) {
my @flags = $p->rflags;
next if !($p->rate && any { any { !/^!/ && $fl{$_} } split('\|\|') } @flags);
$p->rate >= 3 ?
push(@firstchoice, $p->name) :
push(@others, $p->name);
}
my $root2 = translate($root->{path}) . '|' . translate($root->{label});
$add_node->($_, $root2) foreach sort @firstchoice;
$add_node->($_, $root2 . '|' . N("Other")) foreach sort @others;
}
}
},
get_info => sub {
my $p = install::pkgs::packageByName($packages, $_[0]) or return '';
my $description = install::pkgs::get_pkg_info($p);
my $imp = translate($install::pkgs::compssListDesc{$p->flag_base ? 5 : $p->rate});
my $tag = { 'foreground' => 'royalblue3' };
[ [ N("Name: "), $tag ], [ $p->name . "\n" ],
[ N("Version: "), $tag ], [ $p->version . '-' . $p->release . "\n" ],
[ N("Size: "), $tag ], [ N("%d KB\n", $p->size / 1024) ],
if_($imp, [ N("Importance: "), $tag ], [ "$imp\n" ]),
[ "\n" ], [ formatLines($description) ] ];
},
toggle_nodes => sub {
my $set_state = shift @_;
my $isSelection = 0;
my %l = map { my $p = install::pkgs::packageByName($packages, $_);
$isSelection ||= !$p->flag_selected;
$p->id => 1 } @_;
my $state = $packages->{state} ||= {};
$packages->{rpmdb} ||= install::pkgs::rpmDbOpen(); #- WORKAROUND
my @l = $isSelection ? $packages->resolve_requested($packages->{rpmdb}, $state, \%l,
no_suggests => $::o->{no_suggests},
callback_choices => \&install::pkgs::packageCallbackChoices) :
$packages->disable_selected($packages->{rpmdb}, $state,
map { $packages->{depslist}[$_] } keys %l);
my $size = install::pkgs::selectedSize($packages);
my $error;
if (!@l) {
#- no package can be selected or unselected.
my @ask_unselect = grep { $state->{rejected}{$_}{backtrack} &&
exists $l{$packages->search($_, strict_fullname => 1)->id} }
keys %{$state->{rejected} || {}};
#- extend to closure (to given more detailed and not absurd reason).
my %ask_unselect;
while (@ask_unselect > keys %ask_unselect) {
@ask_unselect{@ask_unselect} = ();
foreach (keys %ask_unselect) {
foreach (keys %{$state->{rejected}{$_}{backtrack}{closure} || {}}) {
next if exists $ask_unselect{$_};
push @ask_unselect, $_;
}
}
}
$error = [ N("You cannot select/unselect this package"),
formatList(20, map { my $rb = $state->{rejected}{$_}{backtrack};
my @froms = keys %{$rb->{closure} || {}};
my @unsatisfied = @{$rb->{unsatisfied} || []};
my $s = join ", ", ((map { N("due to missing %s", $_) } @froms),
(map { N("due to unsatisfied %s", $_) } @unsatisfied),
$rb->{promote} && !$rb->{keep} ? N("trying to promote %s", join(", ", @{$rb->{promote}})) : @{[]},
$rb->{keep} ? N("in order to keep %s", join(", ", @{$rb->{keep}})) : @{[]},
);
$_ . ($s ? " ($s)" : '');
} sort @ask_unselect) ];
} elsif (install::pkgs::correctSize($size / sqr(1024)) > $available / sqr(1024)) {
$error = N("You cannot select this package as there is not enough space left to install it");
} elsif (@l > @_ && $common->{state}{auto_deps}) {
$o->ask_okcancel(N("Confirmation"), [ $isSelection ?
N("The following packages are going to be installed") :
N("The following packages are going to be removed"),
formatList(20, sort(map { $_->name } @l)) ], 1) or $error = ''; #- defined
}
if (defined $error) {
$o->ask_warn('', $error) if $error;
#- disable selection (or unselection).
$packages->{rpmdb} ||= install::pkgs::rpmDbOpen(); #- WORKAROUND
$isSelection ? $packages->disable_selected($packages->{rpmdb}, $state, @l) :
$packages->resolve_requested($packages->{rpmdb}, $state, { map { $_->id => 1 } @l },
no_suggests => $::o->{no_suggests});
} else {
#- keep the changes, update visible state.
foreach (@l) {
$set_state->($_->name, $_->flag_selected ? 'selected' : 'unselected');
}
}
},
grep_allowed_to_toggle => sub {
grep { my $p = install::pkgs::packageByName($packages, $_); $p && !$p->flag_base } @_;
},
grep_unselected => sub {
grep { !install::pkgs::packageByName($packages, $_)->flag_selected } @_;
},
check_interactive_to_toggle => sub {
my $p = install::pkgs::packageByName($packages, $_[0]) or return;
if ($p->flag_base) {
$o->ask_warn('', N("This is a mandatory package, it cannot be unselected"));
} elsif ($p->flag_installed && !$p->flag_upgrade) {
$o->ask_warn('', N("You cannot unselect this package. It is already installed"));
} elsif ($p->flag_selected && $p->flag_installed) {
$o->ask_warn('', N("You cannot unselect this package. It must be upgraded"));
} else { return 1 }
return;
},
auto_deps => N("Show automatically selected packages"),
interactive_help => sub {
interactive::gtk::display_help($o, { interactive_help_id => 'choosePackagesTree' }) },
ok => N("Install"),
cancel => N("Previous"),
icons => [ { icon => 'floppy',
help => N("Load/Save selection"),
wait_message => N("Updating package selection"),
code => sub { $o->loadSavePackagesOnFloppy($packages); 1 },
},
if_(0,
{ icon => 'feather',
help => N("Minimal install"),
code => sub {
install::any::unselectMostPackages($o);
install::pkgs::setSelectedFromCompssList($packages, { SYSTEM => 1 }, $o->{compssListLevel}, $availableCorrected);
1;
} }),
],
state => {
auto_deps => 1,
},
};
$o->ask_browse_tree_info(N("Software Management"), N("Choose the packages you want to install"), $common);
}
#------------------------------------------------------------------------------
sub beforeInstallPackages {
my ($o) = @_;
$o->SUPER::beforeInstallPackages;
|