package mouse; # $Id$
#use diagnostics;
#use strict;
#-######################################################################################
#- misc imports
#-######################################################################################
use common;
use modules;
use detect_devices;
use run_program;
use devices;
use modules;
use any;
use log;
my @mouses_fields = qw(nbuttons MOUSETYPE XMOUSETYPE name);
my %mice =
arch() =~ /^sparc/ ?
(
'sunmouse' =>
[ [ 'sunmouse' ],
[ [ 3, 'sun', 'sun', __("Sun - Mouse") ]
]]
) :
(
'PS/2' =>
[ [ 'psaux' ],
[ [ 2, 'ps/2', 'PS/2', __("Standard") ],
[ 5, 'ps/2', 'MouseManPlusPS/2', __("Logitech MouseMan+") ],
[ 5, 'imps2', 'IMPS/2', __("Generic PS2 Wheel Mouse") ],
[ 5, 'ps/2', 'GlidePointPS/2', __("GlidePoint") ],
'',
[ 5, 'ps/2', 'ThinkingMousePS/2', __("Kensington Thinking Mouse") ],
[ 5, 'netmouse', 'NetMousePS/2', __("Genius NetMouse") ],
[ 5, 'netmouse', 'NetScrollPS/2', __("Genius NetScroll") ],
]],
'USB' =>
[ [ 'usbmouse' ],
[ if_(arch() eq 'ppc', [ 1, 'ps/2', 'PS/2', __("1 button") ]),
[ 2, 'ps/2', 'PS/2', __("Generic 2 Button Mouse") ],
[ 3, 'ps/2', 'PS/2', __("Generic") ],
[ 5, 'ps/2', 'IMPS/2', __("Wheel") ],
]],
__("serial") =>
[ [ map { "ttyS$_" } 0..3 ],
[ [ 2, 'Microsoft', 'Microsoft', __("Generic 2 Button Mouse") ],
[ 3, 'Microsoft', 'Microsoft', __("Generic 3 Button Mouse") ],
[ 5, 'ms3', 'IntelliMouse', __("Microsoft IntelliMouse") ],
[ 3, 'MouseMan', 'MouseMan', __("Logitech MouseMan") ],
[ 2, 'MouseSystems', 'MouseSystems', __("Mouse Systems") ],
'',
[ 3, 'logim', 'MouseMan', __("Logitech CC Series") ],
[ 5, 'pnp', 'IntelliMouse', __("Logitech MouseMan+/FirstMouse+") ],
[ 5, 'ms3', 'IntelliMouse', __("Genius NetMouse") ],
[ 2, 'MMSeries', 'MMSeries', __("MM Series") ],
[ 2, 'MMHitTab', 'MMHittab', __("MM HitTablet") ],
[ 3, 'Logitech', 'Logitech', __("Logitech Mouse (serial, old C7 type)") ],
[ 3, 'Microsoft', 'ThinkingMouse', __("Kensington Thinking Mouse") ],
]],
__("busmouse") =>
[ [ arch() eq 'ppc' ? 'adbmouse' : ('atibm', 'inportbm', 'logibm') ],
[ if_(arch() eq 'ppc', [ 1, 'Busmouse', 'BusMouse', __("1 button") ]),
[ 2, 'Busmouse', 'BusMouse', __("2 buttons") ],
[ 3, 'Busmouse', 'BusMouse', __("3 buttons") ],
]],
__("none") =>
[ [ 'none' ],
[ [ 0, 'none', 'Microsoft', __("No mouse") ],
]],
);
sub xmouse2xId {
#- xmousetypes must be sorted as found in /usr/include/X11/extensions/xf86misc.h
#- so that first mean "0", etc
my @xmousetypes = (
"Microsoft",
"MouseSystems",
"MMSeries",
"Logitech",
"BusMouse", #MouseMan,
"Logitech",
"PS/2",
"MMHittab",
"GlidePoint",
"IntelliMouse",
"ThinkingMouse",
"IMPS/2",
"ThinkingMousePS/2",
"MouseManPlusPS/2",
"GlidePointPS/2",
"NetMousePS/2",
"NetScrollPS/2",
"SysMouse",
"Auto",
"AceCad",
"WSMouse",
"USB",
);
my ($id) = @_;
$id = 'BusMouse' if $id eq 'MouseMan';
my $i; map_index { $_ eq $id and $i = $::i } @xmousetypes; $i;
}
my %mouse_btn_keymap = (
0 => "NONE",
67 => "F9",
68 => "F10",
87 => "F11",
88 => "F12",
85 => "F13",
89 => "F14",
90 => "F15",
56 => "L-Option/Alt",
125 => "L-Command",
98 => "Num: /",
55 => "Num: *",
117 => "Num: =",
);
sub ppc_one_button_keys { keys %mouse_btn_keymap }
sub ppc_one_button_key2text { $mouse_btn_keymap{$_[0]} }
sub raw2mouse {
my ($type, $raw) = @_;
$raw or return;
my %l; @l{@mouses_fields} = @$raw;
+{ %l, type => $type };
}
sub update_type_name {
my ($mouse) = @_;
while (my ($k, $v) = each %mice) {
$mouse->{device} =~ /usb/ && $k ne 'USB' and next; #- avoid mixing USB and PS/2 mice.
foreach (@{$v->[1]}) {
if ($_->[0] == $mouse->{nbuttons} && $_->[2] eq $mouse->{XMOUSETYPE}) {
add2hash($mouse, { MOUSETYPE => $_->[1],
type => $k,
name => $_->[3],
});
return $mouse;
}
}
}
}
sub fullnames {
map_each {
my $type = $::a;
grep {$_} map {
if ($_) {
my $l = raw2mouse($type, $_);
"$type|$l->{name}";
} else {
$type .= "|[" . _("Other") . "]";
'';
}
} @{$::b->[1]}
} %mice;
}
sub fullname2mouse {
my ($fname, %opts) = @_;
my ($type, @l) = split '\|', $fname;
my ($name) = pop @l;
search:
$opts{device} ||= $mice{$type}[0][0];
foreach (@{$mice{$type}[1]}) {
my $l = raw2mouse($type, $_);
$name eq $l->{name} and return { %$l, %opts };
}
if ($name eq '1 Button') {
$name = "Generic 2 Button Mouse";
goto search;
}
die "$fname not found ($type, $name)";
}
sub serial_ports() { map { "ttyS$_" } 0..7 }
sub serial_port2text {
$_[0] =~ /ttyS(\d+)/ ? "$_[0] / COM" . ($1 + 1) : $_[0];
}
sub read {
my ($prefix) = @_;
my %mouse = getVarsFromSh "$prefix/etc/sysconfig/mouse";
eval { add2hash_(\%mouse, fullname2mouse($mouse{FULLNAME})) };
$mouse{device} = readlink "$prefix/dev/mouse" or log::l("reading $prefix/dev/mouse symlink failed");
$mouse{nbuttons} = $mouse{XEMU3} eq "yes" ? 2 : $mouse{WHEEL} eq "yes" ? 5 : 3;
\%mouse;
}
sub write {
my ($prefix, $mouse) = @_;
local $mouse->{FULLNAME} = qq("$mouse->{type}|$mouse->{name}"); #-"
local $mouse->{XEMU3} = bool2yesno($mouse->{nbuttons} < 3);
local $mouse->{WHEEL} = bool2yesno($mouse->{nbuttons} > 3);
setVarsInSh("$prefix/etc/sysconfig/mouse", $mouse, qw(MOUSETYPE XMOUSETYPE FULLNAME XEMU3 WHEEL device));
any::devfssymlinkf ($mouse->{device}, 'mouse', $prefix) or log::l("creating $prefix/dev/mouse symlink failed");
$mouse->{auxmouse} and any::devfssymlinkf ($mouse->{auxmouse}{device}, 'mouse1', $prefix) or log::l("creating $prefix/dev/mouse1 symlink failed");
if (arch() =~ /ppc/) {
my $s = join('',
"dev.mac_hid.mouse_button_emulation = " . to_bool($mouse->{button2_key} || $mouse->{button3_key}) . "\n",
if_($mouse->{button2_key}, "dev.mac_hid.mouse_button2_keycode = $mouse->{button2_key}\n"),
if_($mouse->{button3_key}, "dev.mac_hid.mouse_button3_keycode = $mouse->{button3_key}\n"),
);
substInFile {
$_ = '' if /^\Qdev.mac_hid.mouse_button/;
$_ .= $s if eof;
} "$prefix/etc/sysctl.conf";
#- hack - dev RPM symlinks to mouse0 - lands on mouse1 with new input layer on PPC input/mice will get both ADB and USB
symlinkf "/dev/input/mice", "$prefix/dev/usbmouse" if ($mouse->{device} eq "usbmouse");
}
}
sub mouseconfig {
my ($t, $mouse, @wacom);
#- Whouah! probing all devices from ttyS0 to ttyS3 once a time!
detect_devices::probeSerialDevices();
#- check new probing methods keep everything used here intact!
foreach (0..3) {
$t = detect_devices::probeSerial("/dev/ttyS$_");
if ($t->{CLASS} eq 'MOUSE') {
$t->{MFG} ||= $t->{MANUFACTURER};
$mouse = fullname2mouse("serial|Microsoft IntelliMouse") if $t->{MFG} eq 'MSH' && $t->{MODEL} eq '0001';
$mouse = fullname2mouse("serial|Logitech MouseMan") if $t->{MFG} eq 'LGI' && $t->{MODEL} =~ /^80/;
$mouse = fullname2mouse("serial|Genius NetMouse") if $t->{MFG} eq 'KYE' && $t->{MODEL} eq '0003';
$mouse ||= fullname2mouse("serial|Generic 2 Button Mouse"); #- generic by default.
$mouse->{device} = "ttyS$_";
last;
} elsif ($t->{CLASS} eq "PEN" || $t->{MANUFACTURER} eq "WAC") {
push @wacom, "ttyS$_";
}
}
$mouse, @wacom;
}
sub detect() {
if (arch() =~ /^sparc/) {
return fullname2mouse("sunmouse|Sun - Mouse");
}
if (arch() eq "ppc") {
return fullname2mouse(detect_devices::hasMousePS2("usbmouse") ?
"USB|1 button" :
# No need to search for an ADB mouse. If I did, the PPC kernel would
# find one whether or not I had one installed! So.. default to it.
"busmouse|1 button");
}
my @wacom;
my $fast_mouse_probe = sub {
my $auxmouse = detect_devices::hasMousePS2("psaux") && fullname2mouse("PS/2|Standard", unsafe => 1);
if (modules::get_alias("usb-interface")) {
if (my (@l) = detect_devices::usbMice()) {
log::l("found usb mouse $_->{driver} $_->{description} ($_->{type})") foreach @l;
eval { modules::load($_) foreach qw(hid mousedev usbmouse) };
if (!$@ && detect_devices::tryOpen("usbmouse")) {
my $mouse = fullname2mouse($l[0]{driver} =~ /Mouse:(.*)/ ? $1 : "USB|Generic");
$auxmouse and $mouse->{auxmouse} = $auxmouse; #- for laptop, we kept the PS/2 as secondary (symbolic).
return $mouse;
}
eval { modules::unload($_) foreach qw(usbmouse mousedev hid) };
}
}
$auxmouse;
};
if (modules::get_alias("usb-interface")) {
my $keep_mouse;
if (my (@l) = detect_devices::usbWacom()) {
log::l("found usb wacom $_->{driver} $_->{description} ($_->{type})") foreach @l;
eval { modules::load("wacom"); modules::load("evdev"); };
unless ($@) {
foreach (0..$#l) {
detect_devices::tryOpen("input/event$_") and $keep_mouse = 1, push @wacom, "input/event$_";
}
}
$keep_mouse or eval { modules::unload("evdev"); modules::unload("wacom"); };
}
}
#- at this level, not all possible mice are detected so avoid invoking serial_probe
#- which takes a while for its probe.
if ($::isStandalone) {
my $mouse = $fast_mouse_probe->();
$mouse and return ($mouse, @wacom);
}
#- probe serial device to make sure a wacom has been detected.
eval { modules::load("serial") };
my ($r, @serial_wacom) = mouseconfig(); push @wacom, @serial_wacom;
if (!$::isStandalone) {
my $mouse = $fast_mouse_probe->();
$r && $mouse and $r->{auxmouse} = $mouse; #- we kept the auxilliary mouse as PS/2.
$r and return ($r, @wacom);
$mouse and return ($mouse, @wacom);
} else {
$r and return ($r, @wacom);
}
#- in case only a wacom has been found, assume an inexistant mouse (necessary).
@wacom and return { CLASS => 'MOUSE',
nbuttons => 2,
device => "nothing",
MOUSETYPE => "Microsoft",
XMOUSETYPE => "Microsoft"}, @wacom;
if (!modules::get_alias("usb-interface") && detect_devices::is_a_recent_computer() && $::isInstall && !$::noauto) {
#- special case for non detected usb interface on a box with no mouse.
#- we *must* find out if there really is no usb, otherwise the box may
#- not be accessible via the keyboard (if the keyboard is USB)
#- the only way to know this is to make a full pci probe
modules::load_thiskind("usb", '', 'unsafe');
if (my $mouse = $fast_mouse_probe->()) {
return $mouse;
}
}
#- defaults to generic serial mouse on ttyS0.
#- Oops? using return let return a hash ref, if not using it, it return a list directly :-)
return fullname2mouse("serial|Generic 2 Button Mouse", unsafe => 1);
}
#- write_conf : write the mouse infos into the Xconfig files.
#- input :
#- $mouse : the hashtable containing the informations
#- $mouse input
#- $mouse->{nbuttons} : number of buttons : integer
#- $mouse->{device} : device of the mouse : string : ex 'psaux'
#- $mouse->{XMOUSETYPE} : type of the mouse for gpm : string : ex 'PS/2'
#- $mouse->{type} : type (generic ?) of the mouse : string : ex 'PS/2'
#- $mouse->{name} : name of the mouse : string : ex 'Standard'
#- $mouse->{MOUSETYPE} : type of the mouse : string : ex "ps/2"
#- $mouse->{XEMU3} : emulate 3rd button : string : 'yes' or 'no'
sub write_conf {
my ($mouse) = @_;
&write('', $mouse);
modules::write_conf('') if $mouse->{device} eq "usbmouse" && !$::testing;
my $f = "/etc/X11/XF86Config";
my $g = "/etc/X11/XF86Config-4";
my $update_mouse = sub {
my ($mouse) = @_;
my ($zaxis, $zaxis_aux) = map { [
$_->{nbuttons} > 3 ? [ "ZAxisMapping", "4 5" ] : (),
$_->{nbuttons} > 5 ? [ "ZAxisMapping", "6 7" ] : (),
$_->{nbuttons} < 3 ? ([ "Emulate3Buttons" ], [ "Emulate3Timeout", "50" ]) : ()
] } grep { $_ } ($mouse, $mouse->{auxmouse});
my ($str_zaxis, $str_zaxis_aux) = map { join('', map { qq(\n $_->[0]) . ($_->[1] && qq( $_->[1])) } @$_)
} grep { $_ } ($zaxis, $zaxis_aux);
my $found_auxmouse = 0;
substInFile {
if (/^Section\s+"Pointer"/ .. /^EndSection/) {
$_ = '' if /(ZAxisMapping|Emulate3)/; #- remove existing line
s|^(\s*Protocol\s+).*|$1"$mouse->{XMOUSETYPE}"|;
s|^(\s*Device\s+).*|$1"/dev/$mouse->{device}"$str_zaxis|;
}
if ($mouse->{auxmouse}) {
if (/DeviceName\s+"Mouse2"/ .. /^EndSection/) {
$found_auxmouse = 1;
$_ = '' if /(ZAxisMapping|Emulate3|AlwaysCore)/; #- remove existing line
s|^(\s*Protocol\s+).*|$1"$mouse->{auxmouse}{XMOUSETYPE}"|;
s|^(\s*Device\s+).*|$1"/dev/$mouse->{auxmouse}{device}"\n AlwaysCore$str_zaxis_aux|;
}
}
} $f if -e $f && !$::testing;
substInFile {
if (my $l = /^Section\s+"Pointer"/ .. /^EndSection/) {
$l =~ /E/ and $_ .= qq(
Section "XInput"
SubSection "Mouse"
DeviceName "Mouse2"
Protocol "$mouse->{auxmouse}{XMOUSETYPE}"
Device "/dev/$mouse->{auxmouse}{device}"
AlwaysCore$str_zaxis_aux
EndSubSection
EndSection
);
}
} $f if !$found_auxmouse && $mouse->{auxmouse} && -e $f && !$::testing;
($str_zaxis, $str_zaxis_aux) = map { join('', map { qq(\n Option "$_->[0]") . ($_->[1] && qq( "$_->[1]")) } @$_)
} grep { $_ } ($zaxis, $zaxis_aux);
$found_auxmouse = 0;
substInFile {
if (/Identifier\s+"Mouse1"/ .. /^EndSection/) {
$_ = '' if /(ZAxisMapping|Emulate3)/; #- remove existing line
s|^(\s*Option\s+"Protocol"\s+).*|$1"$mouse->{XMOUSETYPE}"|; #"
s|^(\s*Option\s+"Device"\s+).*|$1"/dev/mouse"$str_zaxis|;
}
if ($mouse->{auxmouse}) {
if (/Identifier\s+"Mouse2"/ .. /^EndSection/) {
$found_auxmouse = 1;
$_ = '' if /(ZAxisMapping|Emulate3)/; #- remove existing line
s|^(\s*Option\s+"Protocol"\s+).*|$1"$mouse->{auxmouse}{XMOUSETYPE}"|; #"
s|^(\s*Option\s+"Device"\s+).*|$1"/dev/$mouse->{auxmouse}{device}"$str_zaxis_aux|; #"
}
}
} $g if -e $g && !$::testing;
substInFile {
if (my $l = /Identifier\s+"Mouse1"/ .. /^EndSection/) {
$l =~ /E/ and $_ .= qq(
Section "InputDevice"
Identifier "Mouse2"
Option "Protocol" "$mouse->{auxmouse}{XMOUSETYPE}"
Option "Device" "/dev/$mouse->{auxmouse}{XMOUSETYPE}"$str_zaxis_aux
EndSection
);
}
} $g if !$found_auxmouse && $mouse->{auxmouse} && -e $g && !$::testing;
};
$update_mouse->($mouse);
}
sub test_mouse_install {
my ($mouse) = @_;
require my_gtk;
my_gtk->import(qw(:wrappers :helpers));
my $w = my_gtk->new;
my ($width, $height, $offset) = (210, round_up(min(350, $::windowheight - 150), 6), 25);
my $darea = new Gtk::DrawingArea;
$darea->set_events([ 'button_press_mask', 'button_release_mask' ]); #$darea must be unrealized.
gtkadd($w->{window},
gtkpack(my $vbox_grab = new Gtk::VBox(0,0),
gtksize(gtkset_usize($darea, $width+1, $height+1), $width+1, $height+1),
my $okcancel = gtkset_sensitive(create_okcancel($w, '', '', "edge"), 1)
),
);
$okcancel->set_uposition(7, $height-43);
Gtk->timeout_add(2000, sub { gtkset_sensitive($okcancel, 1); $okcancel->draw(undef); });
test_mouse($mouse, $w, $darea, $width, $height);
$w->{window}->set_usize(undef, $height+10);
$w->sync; # HACK
Gtk::Gdk->pointer_grab($darea->window, 1,
[ 'pointer_motion_mask'],
$darea->window, undef ,0);
$w->main;
}
sub test_mouse_standalone {
my ($mouse, $hbox) = @_;
require my_gtk;
my_gtk->import(qw(:wrappers));
my ($width, $height, $offset) = (210, round_up(min(350, $::windowheight - 150), 6), 25);
my $darea = new Gtk::DrawingArea;
$darea->set_events([ 'button_press_mask', 'button_release_mask' ]); #$darea must be unrealized.
gtkpack($hbox,
gtkpack(gtkset_border_width(new Gtk::VBox(0,10), 10),
gtksize(gtkset_usize($darea, $width+1, $height+1), $width, $height)
)
);
test_mouse($mouse, $hbox, $darea, $width, $height);
}
sub test_mouse {
my ($mouse, $w, $darea, $width, $height) = @_;
$darea->realize();
my $wait = 0;
my ($m3_image, $m3_mask) = gtkcreate_xpm('mouse_3b.xpm');
my ($m3_imagep, $m3_maskp) = gtkcreate_xpm('mouse_3b+.xpm');
my ($m3_left, $m3_left_mask) = gtkcreate_xpm('mouse_left.xpm');
my ($m3_right, $m3_right_mask) = gtkcreate_xpm('mouse_right.xpm');
my ($m3_middle, $m3_middle_mask) = gtkcreate_xpm('mouse_middle.xpm');
my ($aru, $aru_mask) = gtkcreate_xpm('arrow_up.xpm');
my ($ard, $ard_mask) = gtkcreate_xpm('arrow_down.xpm');
my $image = $m3_image;
$mouse->{nbuttons} > 3 and $image = $m3_imagep;
my $draw_text = sub {
my ($t, $y) = @_;
my $font = $darea->style->font;
my $w = $font->string_width($t);
$darea->window->draw_string($font, $darea->style->black_gc, ($darea->allocation->[2]-$width)/2 + ($width - $w) / 2, ($darea->allocation->[3]-$height)/2 + $y, $t);
};
my $drawarea; $drawarea = sub { $darea->window->draw_pixmap ($darea->style->bg_gc('normal'),
$image, 0, 0,
($darea->allocation->[2]-$width)/2, ($darea->allocation->[3]-$height)/2,
210, 350);
$draw_text->(_("Please test the mouse"), $height - 120);
$draw_text->(_("To activate the mouse,"), $height - 105) if $mouse->{XMOUSETYPE} eq 'IMPS/2';
$draw_text->(_("MOVE YOUR WHEEL!"), $height - 90) if $mouse->{XMOUSETYPE} eq 'IMPS/2';
return if $::isStandalone;
$darea->window->draw_rectangle($darea->style->bg_gc('normal'), 1, 0, $height-65, $width, $height);
};
my $paintButton = sub {
my ($nb, $pressed) = @_;
my $x = 60 + $nb*33;
$drawarea->();
if ($nb == 0) {
$darea->window->draw_pixmap ($darea->style->bg_gc('normal'),
$m3_left, 0, 0,
($darea->allocation->[2]-$width)/2+31, ($darea->allocation->[3]-$height)/2 + 52,
59, 91);
} elsif ($nb == 2) {
$darea->window->draw_pixmap ($darea->style->bg_gc('normal'),
$m3_right, 0, 0,
($darea->allocation->[2]-$width)/2+117, ($darea->allocation->[3]-$height)/2 + 52,
61, 91);
} elsif ($nb == 1) {
if ($mouse->{nbuttons} > 3) {
$darea->window->draw_pixmap ($darea->style->bg_gc('normal'),
$m3_middle, 0, 0,
($darea->allocation->[2]-$width)/2+98, ($darea->allocation->[3]-$height)/2 + 67,
13, 62);
} else {
$darea->window->draw_arc ( $darea->style->black_gc,
1, ($darea->allocation->[2]-$width)/2 + $x, ($darea->allocation->[3]-$height)/2 + 90, 20, 25,
0, 360*64);
}
} elsif ($nb == 3) {
$wait=1;
$darea->window->draw_pixmap ($darea->style->bg_gc('normal'),
$aru, 0, 0,
($darea->allocation->[2]-$width)/2+102, ($darea->allocation->[3]-$height)/2 + 57,
6, 8);
$darea->window->draw_pixmap ($darea->style->bg_gc('normal'),
$m3_middle, 0, 0,
($darea->allocation->[2]-$width)/2+98, ($darea->allocation->[3]-$height)/2 + 67,
13, 62);
Gtk->timeout_add(200, sub { $wait = 0 });
} elsif ($nb == 4) {
$wait=1;
$darea->window->draw_pixmap ($darea->style->bg_gc('normal'),
$ard, 0, 0,
($darea->allocation->[2]-$width)/2+102, ($darea->allocation->[3]-$height)/2 + 131,
6, 8);
$darea->window->draw_pixmap ($darea->style->bg_gc('normal'),
$m3_middle, 0, 0,
($darea->allocation->[2]-$width)/2+98, ($darea->allocation->[3]-$height)/2 + 67,
13, 62);
Gtk->timeout_add(200, sub { $wait = 0 });
}
};
$darea->signal_connect(button_press_event => sub {
my $b = $_[1]{button};
$paintButton->($b - 1);
});
$darea->signal_connect(button_release_event => sub {
while ($wait) { my_gtk::flush() }
$drawarea->()
});
$darea->signal_connect(expose_event => sub { $drawarea->() });
$darea->size($width, $height);
}
='n410' href='#n410'>410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
package interactive; # $Id$
use diagnostics;
use strict;
#-######################################################################################
#- misc imports
#-######################################################################################
use MDK::Common::Func;
use common;
use do_pkgs;
#- minimal example using interactive:
#
#- > use lib qw(/usr/lib/libDrakX);
#- > use interactive;
#- > my $in = interactive->vnew;
#- > $in->ask_okcancel('title', 'question');
#- > $in->exit;
#- ask_from_ takes global options ($common):
#- title => window title
#- messages => message displayed in the upper part of the window
#- advanced_messages => message displayed when "Advanced" is pressed
#- ok => force the name of the "Ok"/"Next" button
#- cancel => force the name of the "Cancel"/"Previous" button
#- advanced_label => force the name of the "Advanced" button
#- advanced_label_close => force the name of the "Basic" button
#- advanced_state => if set to 1, force the "Advanced" part of the dialog to be opened initially
#- focus_cancel => force focus on the "Cancel" button
#- focus_first => force focus on the first entry
#- callbacks => functions called when something happen: complete canceled advanced changed focus_out ok_disabled
#- ask_from_ takes a list of entries with fields:
#- val => reference to the value
#- label => description
#- icon => icon to put before the description
#- help => tooltip
#- advanced => wether it is shown in by default or only in advanced mode
#- disabled => function returning wether it should be disabled (grayed)
#- gtk => gtk preferences
#- type =>
#- button => (with clicked or clicked_may_quit)
#- (type defaults to button if clicked or clicked_may_quit is there)
#- (val need not be a reference) (if clicked_may_quit return true, it's as if "Ok" was pressed)
#- label => (val need not be a reference) (type defaults to label if val is not a reference)
#- bool (with "text" or "image" (which overrides text) giving an image filename)
#- range (with min, max)
#- combo (with list, not_edit, format)
#- list (with list, icon2f (aka icon), separator (aka tree), format (aka pre_format function),
#- help can be a hash or a function,
#- tree_expanded boolean telling wether the tree should be wide open by default
#- quit_if_double_click boolean
#- allow_empty_list disables the special cases for 0 and 1 element lists
#- image2f is a subroutine which takes a value of the list as parameter, and returns an array (text, image_file_name))
#- entry (the default) (with hidden)
#
#- heritate from this class and you'll get all made interactivity for same steps.
#- for this you need to provide
#- - ask_from_listW(o, title, messages, arrayref, default) returns one string of arrayref
#-
#- where
#- - o is the object
#- - title is a string
#- - messages is an refarray of strings
#- - default is an optional string (default is in arrayref)
#- - arrayref is an arrayref of strings
#- - arrayref2 contains booleans telling the default state,
#-
#- ask_from_list and ask_from_list_ are wrappers around ask_from_biglist and ask_from_smalllist
#-
#- ask_from_list_ just translate arrayref before calling ask_from_list and untranslate the result
#-
#- ask_from_listW should handle differently small lists and big ones.
#-
#-######################################################################################
#- OO Stuff
#-######################################################################################
our @ISA = qw(do_pkgs);
sub new($) {
my ($type) = @_;
bless {}, ref($type) || $type;
}
sub vnew {
my ($_type, $o_su, $o_icon) = @_;
my $su = $o_su eq "su";
if ($ENV{INTERACTIVE_HTTP}) {
require interactive::http;
return interactive::http->new;
}
require c;
if ($su) {
$ENV{PATH} = "/sbin:/usr/sbin:$ENV{PATH}";
$su = '' if $::testing || $ENV{TESTING};
}
require_root_capability() if $su;
if (check_for_xserver()) {
eval { require interactive::gtk };
if (!$@) {
my $o = interactive::gtk->new;
if ($o_icon && $o_icon ne 'default' && !$::isWizard) { $o->{icon} = $o_icon } else { undef $o->{icon} }
return $o;
} elsif ($::testing) {
die;
}
}
require 'log.pm'; #- "require log" causes some pb, perl thinking that "log" is the log() function
undef *log::l;
*log::l = sub {}; # otherwise, it will bother us :(
require interactive::newt;
interactive::newt->new;
}
sub enter_console {}
sub leave_console {}
sub suspend {}
sub resume {}
sub end {}
sub exit { exit($_[0]) }
#-######################################################################################
#- Interactive functions
#-######################################################################################
sub ask_warn {
my ($o, $title, $message) = @_;
ask_warn_($o, { title => $title, messages => $message });
}
sub ask_yesorno {
my ($o, $title, $message, $b_def) = @_;
ask_yesorno_($o, { title => $title, messages => $message }, $b_def);
}
sub ask_okcancel {
my ($o, $title, $message, $b_def) = @_;
ask_okcancel_($o, { title => $title, messages => $message }, $b_def);
}
sub ask_warn_ {
my ($o, $common) = @_;
ask_from_listf_raw_no_check($o, $common, undef, [ $o->ok ]);
}
sub ask_yesorno_ {
my ($o, $common, $b_def) = @_;
$common->{cancel} = '';
ask_from_listf_raw($o, $common, sub { translate($_[0]) }, [ N_("Yes"), N_("No") ], $b_def ? "Yes" : "No") eq "Yes";
}
sub ask_okcancel_ {
my ($o, $common, $b_def) = @_;
if ($::isWizard) {
$::no_separator = 1;
$common->{focus_cancel} = !$b_def;
ask_from_no_check($o, $common, []);
} else {
ask_from_listf_raw($o, $common, sub { translate($_[0]) }, [ $o->ok, $o->cancel ], $b_def ? $o->ok : "Cancel") eq $o->ok;
}
}
sub ask_filename {
my ($o, $common) = @_;
$common->{want_a_dir} = 0;
$o->ask_fileW($common);
}
sub ask_directory {
my ($o, $common) = @_;
$common->{want_a_dir} = 1;
$o->ask_fileW($common);
}
#- predecated
sub ask_file {
my ($o, $title, $o_dir) = @_;
$o->ask_fileW({ title => $title, want_a_dir => 0, directory => $o_dir });
}
sub ask_fileW {
my ($o, $common) = @_;
$o->ask_from_entry($common->{title}, $common->{message} || N("Choose a file"));
}
sub ask_from_list {
my ($o, $title, $message, $l, $o_def) = @_;
ask_from_listf($o, $title, $message, undef, $l, $o_def);
}
sub ask_from_list_ {
my ($o, $title, $message, $l, $o_def) = @_;
ask_from_listf($o, $title, $message, sub { translate($_[0]) }, $l, $o_def);
}
sub ask_from_listf_ {
my ($o, $title, $message, $f, $l, $o_def) = @_;
ask_from_listf($o, $title, $message, sub { translate($f->(@_)) }, $l, $o_def);
}
sub ask_from_listf {
my ($o, $title, $message, $f, $l, $o_def) = @_;
ask_from_listf_raw($o, { title => $title, messages => $message }, $f, $l, $o_def);
}
sub ask_from_listf_raw {
my ($_o, $_common, $_f, $l, $_o_def) = @_;
@$l == 0 and die "ask_from_list: empty list\n" . backtrace();
@$l == 1 and return $l->[0];
goto &ask_from_listf_raw_no_check;
}
sub ask_from_listf_raw_no_check {
my ($o, $common, $f, $l, $o_def) = @_;
if (@$l <= ($::isWizard ? 1 : 2)) {
my ($ok, $cancel) = map { $_ && may_apply($f, $_) } @$l;
if (length "$ok$cancel" < 70) {
my $ret = eval {
put_in_hash($common, { ok => $ok,
if_($cancel, cancel => $cancel, focus_cancel => $o_def eq $l->[1]) });
ask_from_no_check($o, $common, []) ? $l->[0] : $l->[1];
};
die if $@ && $@ !~ /^wizcancel/;
return $@ ? undef : $ret;
}
}
ask_from_no_check($o, $common, [ { val => \$o_def, type => 'list', list => $l, format => $f } ]) && $o_def;
}
sub ask_from_treelist {
my ($o, $title, $message, $separator, $l, $o_def) = @_;
ask_from_treelistf($o, $title, $message, $separator, undef, $l, $o_def);
}
sub ask_from_treelist_ {
my ($o, $title, $message, $separator, $l, $o_def) = @_;
my $transl = sub { join '|', map { translate($_) } split(quotemeta($separator), $_[0]) };
ask_from_treelistf($o, $title, $message, $separator, $transl, $l, $o_def);
}
sub ask_from_treelistf {
my ($o, $title, $message, $separator, $f, $l, $o_def) = @_;
ask_from($o, $title, $message, [ { val => \$o_def, separator => $separator, list => $l, format => $f, sort => 1 } ]) or return;
$o_def;
}
sub ask_many_from_list {
my ($o, $title, $message, @l) = @_;
@l = grep { @{$_->{list}} } @l or return '';
foreach my $h (@l) {
$h->{e}{$_} = {
text => may_apply($h->{label}, $_),
val => $h->{val} ? $h->{val}->($_) : do {
my $i =
$h->{value} ? $h->{value}->($_) :
$h->{values} ? member($_, @{$h->{values}}) : 0;
\$i;
},
type => 'bool',
help => may_apply($h->{help}, $_, ''),
icon => may_apply($h->{icon2f}, $_, ''),
} foreach @{$h->{list}};
if ($h->{sort}) {
$h->{list} = [ sort { $h->{e}{$a}{text} cmp $h->{e}{$b}{text} } @{$h->{list}} ];
}
}
$o->ask_from($title, $message, [ map { my $h = $_; map { $h->{e}{$_} } @{$h->{list}} } @l ]) or return;
@l = map {
my $h = $_;
[ grep { ${$h->{e}{$_}{val}} } @{$h->{list}} ];
} @l;
wantarray() ? @l : $l[0];
}
sub ask_from_entry {
my ($o, $title, $message, %callback) = @_;
first(ask_from_entries($o, $title, $message, [''], %callback));
}
sub ask_from_entries {
my ($o, $title, $message, $l, %callback) = @_;
my @l = map { my $i = ''; { label => $_, val => \$i } } @$l;
$o->ask_from_({ title => $title, messages => $message, callbacks => \%callback,
focus_first => 1 }, \@l) or return;
map { ${$_->{val}} } @l;
}
sub ask_from__add_modify_remove {
my ($o, $title, $message, $l, %callback) = @_;
die "ask_from__add_modify_remove only handles one item" if @$l != 1;
$callback{$_} or internal_error("missing callback $_") foreach qw(Add Modify Remove);
if ($o->can('ask_from__add_modify_removeW')) {
$o->ask_from__add_modify_removeW($title, $message, $l, %callback);
} else {
my $e = $l->[0];
my $chosen_element;
put_in_hash($e, { allow_empty_list => 1, val => \$chosen_element, type => 'list' });
while (1) {
my $continue;
my @l = (@$l,
map { my $s = $_; { val => translate($_), clicked_may_quit => sub {
my $r = $callback{$s}->($chosen_element);
defined $r or return;
$continue = 1;
} } }
N_("Add"), if_(@{$e->{list}} > 0, N_("Modify"), N_("Remove")));
$o->ask_from_({ title => $title, messages => $message, callbacks => \%callback }, \@l) or return;
return 1 if !$continue;
}
}
}
#- can get a hash of callback: focus_out changed and complete
#- moreove if you pass a hash with a field list -> combo
#- if you pass a hash with a field hidden -> emulate stty -echo
sub ask_from {
my ($o, $title, $message, $l, %callback) = @_;
ask_from_($o, { title => $title, messages => $message, callbacks => \%callback }, $l);
}
sub ask_from_normalize {
my ($o, $common, $l) = @_;
ref($l) eq 'ARRAY' or internal_error('ask_from_normalize');
foreach my $e (@$l) {
if (my $li = $e->{list}) {
ref($e->{val}) =~ /SCALAR|REF/ or internal_error($e->{val} ? "field {val} must be a reference (it is $e->{val})" : "field {val} is mandatory"); #-#
if ($e->{sort} || @$li > 10 && !exists $e->{sort}) {
my @l2 = map { may_apply($e->{format}, $_) } @$li;
my @places = sort { $l2[$a] cmp $l2[$b] } 0 .. $#l2;
$e->{list} = $li = [ map { $li->[$_] } @places ];
}
$e->{type} = 'iconlist' if $e->{icon2f};
$e->{type} = 'treelist' if $e->{separator};
add2hash_($e, { not_edit => 1 });
$e->{type} ||= 'combo';
if (!$e->{not_edit}) {
die q(when using "not_edit" you must use strings, not a data structure) if ref(${$e->{val}}) || any { ref $_ } @$li;
}
if ($e->{type} ne 'combo' || $e->{not_edit}) {
${$e->{val}} = $li->[0] if !member(may_apply($e->{format}, ${$e->{val}}), map { may_apply($e->{format}, $_) } @$li);
}
} elsif ($e->{type} eq 'range') {
$e->{min} <= $e->{max} or die "bad range min $e->{min} > max $e->{max} (called from " . join(':', caller()) . ")";
${$e->{val}} = max($e->{min}, min(${$e->{val}}, $e->{max}));
} elsif ($e->{type} eq 'button' || $e->{clicked} || $e->{clicked_may_quit}) {
$e->{type} = 'button';
$e->{clicked_may_quit} ||= $e->{clicked} ? sub { $e->{clicked}(); 0 } : sub {};
$e->{val} = \ (my $_v = $e->{val}) if !ref($e->{val});
} elsif ($e->{type} eq 'label' || !ref($e->{val})) {
$e->{type} = 'label';
$e->{val} = \ (my $_v = $e->{val}) if !ref($e->{val});
} else {
$e->{type} ||= 'entry';
}
$e->{disabled} ||= sub { 0 };
}
#- do not display empty lists and one element lists
@$l = grep {
if ($_->{list} && $_->{not_edit} && !$_->{allow_empty_list}) {
if (!@{$_->{list}}) {
eval {
require 'log.pm'; #- "require log" causes some pb, perl thinking that "log" is the log() function
log::l("ask_from_normalize: empty list for $_->{label}\n" . backtrace());
};
}
@{$_->{list}} > 1;
} else {
1;
}
} @$l;
if (!$common->{title} && $::isStandalone) {
($common->{title} = $0) =~ s|.*/||;
}
$common->{interactive_help} ||= $o->{interactive_help};
$common->{interactive_help} ||= $common->{interactive_help_id} && $o->interactive_help_sub_get_id($common->{interactive_help_id});
$common->{advanced_label} ||= N("Advanced");
$common->{advanced_label_close} ||= N("Basic");
$common->{$_} = $common->{$_} ? [ deref($common->{$_}) ] : [] foreach qw(messages advanced_messages);
add2hash_($common->{callbacks} ||= {}, { changed => sub {}, focus_out => sub {}, complete => sub { 0 }, canceled => sub { 0 }, advanced => sub {} });
}
sub ask_from_ {
my ($o, $common, $l) = @_;
ask_from_normalize($o, $common, $l);
@$l or return 1;
$common->{cancel} = '' if !defined wantarray();
ask_from_real($o, $common, $l);
}
sub ask_from_no_check {
my ($o, $common, $l) = @_;
ask_from_normalize($o, $common, $l);
$common->{cancel} = '' if !defined wantarray();
my ($l1, $l2) = partition { !$_->{advanced} } @$l;
$o->ask_fromW($common, $l1, $l2);
}
sub ask_from_real {
my ($o, $common, $l) = @_;
my ($l1, $l2) = partition { !$_->{advanced} } @$l;
my $v = $o->ask_fromW($common, $l1, $l2);
foreach my $e (@$l1, @$l2) {
if ($e->{type} eq 'range') {
${$e->{val}} = max($e->{min}, min(${$e->{val}}, $e->{max}));
}
}
%$common = ();
$v;
}
sub ask_browse_tree_info {
my ($o, $title, $message, $common) = @_;
$common->{interactive_help} ||= $common->{interactive_help_id} && $o->interactive_help_sub_get_id($common->{interactive_help_id});
add2hash_($common, { ok => $::isWizard ? ($::Wizard_finished ? N("Finish") : N("Next")) : N("Ok"),
cancel => $::isWizard ? N("Previous") : N("Cancel") });
add2hash_($common, { title => $title, message => $message });
add2hash_($common, { grep_allowed_to_toggle => sub { @_ },
grep_unselected => sub { grep { $common->{node_state}($_) eq 'unselected' } @_ },
check_interactive_to_toggle => sub { 1 },
toggle_nodes => sub {
my ($set_state, @nodes) = @_;
my $new_state = !$common->{grep_unselected}($nodes[0]) ? 'selected' : 'unselected';
$set_state->($_, $new_state) foreach @nodes;
},
});
$o->ask_browse_tree_info_refW($common);
}
sub ask_browse_tree_info_refW { #- default definition, do not use with too many items (memory consuming)
my ($o, $common) = @_;
my ($l, $v, $h) = ([], [], {});
$common->{build_tree}(sub {
my ($node) = $common->{grep_allowed_to_toggle}(@_);
if (my $state = $node && $common->{node_state}($node)) {
push @$l, $node;
$state eq 'selected' and push @$v, $node;
$h->{$node} = $state eq 'selected';
}
}, 'flat');
add2hash_($common, { list => $l, #- TODO interactivity of toggle is missing
values => $v,
help => sub { $common->{get_info}($_[0]) },
});
my ($new_v) = $o->ask_many_from_list($common->{title}, $common->{message}, $common) or return;
$common->{toggle_nodes}(sub {}, grep { ! delete $h->{$_} } @$new_v);
$common->{toggle_nodes}(sub {}, grep { $h->{$_} } keys %$h);
1;
}
sub wait_message {
my ($o, $title, $message, $b_temp) = @_;
my $w = $o->wait_messageW($title, [ N("Please wait"), deref($message) ]);
push @tempory::objects, $w if $b_temp;
my $b = before_leaving { $o->wait_message_endW($w) };
#- enable access through set
MDK::Common::Func::add_f4before_leaving(sub { $o->wait_message_nextW([ deref($_[1]) ], $w) }, $b, 'set');
$b;
}
sub kill() {}
sub helper_separator_tree_to_tree {
my ($separator, $list, $formatted_list) = @_;
my $sep = quotemeta $separator;
my $tree = {};
each_index {
my @l = split $sep;
my $leaf = pop @l;
my $node = $tree;
foreach (@l) {
$node = $node->{$_} ||= do {
my $r = {};
push @{$node->{_order_}}, $_;
$r;
};
}
push @{$node->{_leaves_}}, [ $leaf, $list->[$::i] ];
();
} @$formatted_list;
$tree;
}
sub interactive_help_has_id {
my ($_o, $id) = @_;
exists $help::{$id};
}
sub interactive_help_get_id {
my ($_o, @l) = @_;
@l = map {
join("\n\n", map { s/\n/ /mg; $_ } split("\n\n", translate($help::{$_}->())));
} grep { exists $help::{$_} } @l;
join("\n\n\n", @l);
}
sub interactive_help_sub_get_id {
my ($o, $id) = @_;
$o->interactive_help_has_id($id) && sub { $o->interactive_help_get_id($id) };
}
sub interactive_help_sub_display_id {
my ($o, $id) = @_;
$o->interactive_help_has_id($id) && sub { $o->ask_warn(N("Help"), $o->interactive_help_get_id($id)) };
}
1;
|