project-renard / p5-Renard-Incunabula-Frontend-Gtk3 / 33

pending completion

Build # 33

Build Type

Pull #7

travis-ci

Committed by

web-flow

Commit Message

Disable XInput 2 by default under X11

This fixes some problems with GDK input especially a problem with mouse
scrolling.

See also:
  - <https://bugzilla.mozilla.org/show_bug.cgi?id=1170342>
  - <https://bugzilla.mozilla.org/show_bug.cgi?id=1207973>
  - <https://bugzilla.mozilla.org/show_bug.cgi?id=1182700>
  - <https://bugzilla.mozilla.org/show_bug.cgi?id=1173971>
  - <https://bugzilla.redhat.com/show_bug.cgi?id=1226465>
  - <https://www.eclipse.org/eclipse/development/readme_eclipse_4.5.php>
  - <https://bugs.eclipse.org/bugs/show_bug.cgi?id=435742>
  - <https://github.com/ibus/ibus/commit/d37c8bbdf>

Pull Request Pull Request #7: Disable XInput 2 by default under X11

Run Details

16 of 16 new or added lines in 1 file covered. (100.0%)

31 of 39 relevant lines covered (79.49%)

1.23 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

79.49

/lib/Renard/Incunabula/Frontend/Gtk3/Helper.pm

use Renard::Incunabula::Common::Setup;
package Renard::Incunabula::Frontend::Gtk3::Helper;

# ABSTRACT: Collection of helper utilities for Gtk3 and Glib

=for :header
=for stopwords gval genum

=cut

use Renard::Incunabula::Common::Types qw(Str);
use Env qw($DISPLAY $RENARD_USE_XINPUT2);
use Class::Method::Modifiers;
use Gtk3;
use Function::Parameters;

our $LOADED = 0;

fun _scrolled_window_viewport_shim() {
        # Note: The code below is marked as uncoverable because it only applies
        # to a single version of GTK+ and thus is not part of the general
        # coverage. The functionality that it adds is tested in other ways.
        # uncoverable branch true
        if( not Gtk3::CHECK_VERSION('3', '8', '0') ) {
                # For versions of Gtk+ less than v3.8.0, we need to call
                # `Gtk3::ScrolledWindow->add_with_viewport( ... )` so that the
                # child widget gets placed in a viewport.
                #
                # Newer versions of Gtk+ automatically create the viewport when
                # `Gtk3::ScrolledWindow->add( ... )` is called.
                #
                # See:
                # - <https://developer.gnome.org/gtk3/3.6/GtkScrolledWindow.html>
                # - <https://developer.gnome.org/gtk3/3.8/GtkScrolledWindow.html>
                Class::Method::Modifiers::install_modifier
                        "Gtk3::ScrolledWindow",
                        around => add => fun(@) {
                                # uncoverable subroutine
                                my $orig = shift;             # uncoverable statement
                                my $self = shift;             # uncoverable statement
                                $self->add_with_viewport(@_); # uncoverable statement
                        };                                    # uncoverable statement
        }
}

fun _can_set_theme() {
        # uncoverable branch true
        return $^O ne 'MSWin32' && Gtk3::CHECK_VERSION('3', '20', '1');
}

fun _set_theme( (Str) $theme_name ) {
        # uncoverable subroutine
        # uncoverable branch true
        return unless _can_set_theme;

        my $adwaita = Gtk3::CssProvider::get_named('Adawaita')->to_string;  # uncoverable statement
        my $custom = Gtk3::CssProvider::get_named($theme_name)->to_string;  # uncoverable statement
        if( $adwaita ne $custom ) {                                         # uncoverable statement
                my $settings = Gtk3::Settings::get_default;                 # uncoverable statement
                $settings->set_property('gtk-theme-name', $theme_name);     # uncoverable statement
        } else {                                                            # uncoverable statement
                warn "Not able to find theme ${theme_name}.\n";             # uncoverable statement
        }                                                                   # uncoverable statement
}


fun _set_icon_theme( (Str) $icon_theme_name ) {
        # uncoverable subroutine
        # uncoverable branch true
        return unless _can_set_theme;

        my $i = Gtk3::IconTheme->new;                                       # uncoverable statement
        $i->set_custom_theme($icon_theme_name);                             # uncoverable statement
        my $n = $i->choose_icon_for_scale(['gtk-open'], 16, 1, 'no-svg');   # uncoverable statement
        my $expected_path = qr,/$icon_theme_name/.*\Qgtk-open.png\E$,;      # uncoverable statement
        if ( defined $n && $n->get_filename =~ $expected_path ) {           # uncoverable statement
                my $settings = Gtk3::Settings::get_default;                 # uncoverable statement
                $settings->set_property('gtk-icon-theme-name',              # uncoverable statement
                        $icon_theme_name);                                  # uncoverable statement
        } else {                                                            # uncoverable statement
                warn "Not able to find icon-theme ${icon_theme_name}.\n";   # uncoverable statement
        }                                                                   # uncoverable statement
}

=func _setup_disable_xinput2

  fun _setup_disable_xinput2() {

Checks to see if running under X11 and that the environment variable
C<< $ENV{RENARD_USE_XINPUT2} >> is not set to a true value.
If so, disables the L<XInput 2 extension|https://www.x.org/wiki/guide/extensions/#index2h2>.

This is necessary because GDK has an issue with some forms of mouse scrolling
under XInput 2. XInput 2 provides support for smooth scrolling, but sometimes
it sends emulated smooth scroll events that have zero for their deltas when
dealing with mice that do not support smooth scrolling natively (i.e., they use
buttons 4 and 5). This prevents widgets from responding.

This is similar to C<< $ENV{GDK_CORE_DEVICE_EVENTS} >> as documented here
L<https://developer.gnome.org/gtk3/stable/gtk-x11.html>.

=cut
fun _setup_disable_xinput2() {
        if( $DISPLAY && ! $RENARD_USE_XINPUT2 ) {
                Gtk3::Gdk::disable_multidevice();
        }
}

=func _setup_gtk

  fun _setup_gtk()

Setup Gtk3.

First, this calls C<< _setup_disable_xinput2() >>.

Then this initialises Gtk3.

=cut
fun _setup_gtk() {
        _setup_disable_xinput2;
        Gtk3::init;
}

fun _gtk_box_shim() {
        my $shim = fun(@) {
                my $orig = shift;
                my $self = shift;
                my $widget = shift;
                if( $widget->can('_gtk_widget') ) {
                        $orig->($self, $widget->_gtk_widget, @_);
                } else {
                        $orig->($self, $widget, @_);
                }
        };
        for my $method (qw(pack_start add)) {
                Class::Method::Modifiers::install_modifier
                        "Gtk3::Box",
                        around => $method => $shim;
        }
}

sub import {
        unless( $::LOADED ) {
                _setup_gtk();
                _scrolled_window_viewport_shim;
                _gtk_box_shim;
                #_set_theme('Flat-Plat');
                #_set_icon_theme('Arc');
                $::LOADED = 1;
        }
        return;
}

# Note: :prototype($$) would help here, but is only possible on Perl v5.20+

=classmethod C<gval>

  classmethod gval( $glib_typename, $value )

Given a L<Glib type name|https://developer.gnome.org/glib/stable/glib-Basic-Types.html>, wraps a
Perl value in an object that can be passed to other L<Glib>-based functions.


=begin :list

* C<$glib_typename>

The name of a type under the C<Glib::> namespace. For
example, passing in C<"int"> gives a wrapper to the C<gint>
C type which is known as C<Glib::Int> in Perl.

* C<$value>

The value to put inside the wrapper.

=end :list

See L<Glib::Object::Introspection::GValueWrapper> in
L<Glib::Object::Introspection> for more information.

=cut
classmethod gval( $glib_typename, $value ) { ## no critic
        # GValue wrapper shortcut
        Glib::Object::Introspection::GValueWrapper->new('Glib::'.ucfirst($glib_typename) => $value);
}

=classmethod genum

  classmethod genum( $package, $sv )

Returns an enumeration value of type C<$package> which contains the matching
enum value given in C<$sv> as a string.

=begin :list

* C<$package>

The package name of a L<Glib> enumeration.

* C<$sv>

A string representation of the enumeration value.

=end :list

For example, for
L<GtkPackType|https://developer.gnome.org/gtk3/stable/gtk3-Standard-Enumerations.html#GtkPackType>
enum, we set C<$package> to C<'Gtk3::PackType'> and C<$sv> to C<'GTK_PACK_START'>.
This can be passed on to other L<Glib::Object::Introspection> methods.

=cut
classmethod genum( $package, $sv ) {
        Glib::Object::Introspection->convert_sv_to_enum($package, $sv);
}

=classmethod callback

  classmethod callback( $invocant, $callback_name, @args )

A helper function to redirect to other callback functions. Given an
C<$invocant> and the name of the callback function, C<$callback_name>, which is
defined in the package of C<$invocant>, calls that function with arguments
C<( @args, $invocant )>.

For example, if we are trying to call the callback function
C<Target::Package::on_event_cb> and C<$target> is a blessed reference of type
C<Target::Package>, then by using

  Renard::Incunabula::Frontend::Gtk3::Helper->callback( $target, on_event_cb => @rest_of_args );

effectively calls

  Target::Package::on_event_cb( @rest_of_args, $target );


=cut
classmethod callback( $invocant, $callback_name, @args ) {
        my $fun = $invocant->can( $callback_name );
        $fun->( @args, $invocant );
}

1;

1	use Renard::Incunabula::Common::Setup;	1✔
2	package Renard::Incunabula::Frontend::Gtk3::Helper;
3
4	# ABSTRACT: Collection of helper utilities for Gtk3 and Glib
5
6	=for :header
7	=for stopwords gval genum	1✔
8		3✔
9	=cut	3✔
10		2✔
11	use Renard::Incunabula::Common::Types qw(Str);	1✔
12	use Env qw($DISPLAY $RENARD_USE_XINPUT2);
13	use Class::Method::Modifiers;
14	use Gtk3;
15	use Function::Parameters;	1✔
16
17	our $LOADED = 0;
18
19	fun _scrolled_window_viewport_shim() {
20	# Note: The code below is marked as uncoverable because it only applies	1✔
21	# to a single version of GTK+ and thus is not part of the general
22	# coverage. The functionality that it adds is tested in other ways.
23	# uncoverable branch true
24	if( not Gtk3::CHECK_VERSION('3', '8', '0') ) {
25	# For versions of Gtk+ less than v3.8.0, we need to call
26	# `Gtk3::ScrolledWindow->add_with_viewport( ... )` so that the
27	# child widget gets placed in a viewport.
28	#
29	# Newer versions of Gtk+ automatically create the viewport when
30	# `Gtk3::ScrolledWindow->add( ... )` is called.
31	#
32	# See:
33	# - <https://developer.gnome.org/gtk3/3.6/GtkScrolledWindow.html>
34	# - <https://developer.gnome.org/gtk3/3.8/GtkScrolledWindow.html>
35	Class::Method::Modifiers::install_modifier
36	"Gtk3::ScrolledWindow",
37	around => add => fun(@) {
38	# uncoverable subroutine
39	my $orig = shift; # uncoverable statement
40	my $self = shift; # uncoverable statement
41	$self->add_with_viewport(@_); # uncoverable statement
42	}; # uncoverable statement	5✔
43	}
44	}	5✔
45
46	fun _can_set_theme() {
47	# uncoverable branch true	2✔
48	return $^O ne 'MSWin32' && Gtk3::CHECK_VERSION('3', '20', '1');
49	}
50		2✔
51	fun _set_theme( (Str) $theme_name ) {
52	# uncoverable subroutine
53	# uncoverable branch true
54	return unless _can_set_theme;
55
56	my $adwaita = Gtk3::CssProvider::get_named('Adawaita')->to_string; # uncoverable statement
57	my $custom = Gtk3::CssProvider::get_named($theme_name)->to_string; # uncoverable statement
58	if( $adwaita ne $custom ) { # uncoverable statement
59	my $settings = Gtk3::Settings::get_default; # uncoverable statement
60	$settings->set_property('gtk-theme-name', $theme_name); # uncoverable statement
61	} else { # uncoverable statement
62	warn "Not able to find theme ${theme_name}.\n"; # uncoverable statement
63	} # uncoverable statement	2✔
64	}
65
66		1✔
67	fun _set_icon_theme( (Str) $icon_theme_name ) {
68	# uncoverable subroutine
69	# uncoverable branch true
70	return unless _can_set_theme;
71
72	my $i = Gtk3::IconTheme->new; # uncoverable statement
73	$i->set_custom_theme($icon_theme_name); # uncoverable statement
74	my $n = $i->choose_icon_for_scale(['gtk-open'], 16, 1, 'no-svg'); # uncoverable statement
75	my $expected_path = qr,/$icon_theme_name/.*\Qgtk-open.png\E$,; # uncoverable statement
76	if ( defined $n && $n->get_filename =~ $expected_path ) { # uncoverable statement
77	my $settings = Gtk3::Settings::get_default; # uncoverable statement
78	$settings->set_property('gtk-icon-theme-name', # uncoverable statement
79	$icon_theme_name); # uncoverable statement
80	} else { # uncoverable statement
81	warn "Not able to find icon-theme ${icon_theme_name}.\n"; # uncoverable statement	1✔
82	} # uncoverable statement	1✔
83	}	×
84
85	=func _setup_disable_xinput2
86
87	fun _setup_disable_xinput2() {	×
88		×
89	Checks to see if running under X11 and that the environment variable	×
90	C<< $ENV{RENARD_USE_XINPUT2} >> is not set to a true value.
91	If so, disables the L<XInput 2 extension\|https://www.x.org/wiki/guide/extensions/#index2h2>.
92		×
93	This is necessary because GDK has an issue with some forms of mouse scrolling
94	under XInput 2. XInput 2 provides support for smooth scrolling, but sometimes	1✔
95	it sends emulated smooth scroll events that have zero for their deltas when	1✔
96	dealing with mice that do not support smooth scrolling natively (i.e., they use	1✔
97	buttons 4 and 5). This prevents widgets from responding.	1✔
98		1✔
99	This is similar to C<< $ENV{GDK_CORE_DEVICE_EVENTS} >> as documented here
100	L<https://developer.gnome.org/gtk3/stable/gtk-x11.html>.	1✔
101
102	=cut	2✔
103	fun _setup_disable_xinput2() {	1✔
104	if( $DISPLAY && ! $RENARD_USE_XINPUT2 ) {	1✔
105	Gtk3::Gdk::disable_multidevice();
106	}
107	}
108
109	=func _setup_gtk
110
111	fun _setup_gtk()	1✔
112		1✔
113	Setup Gtk3.	1✔
114		1✔
115	First, this calls C<< _setup_disable_xinput2() >>.
116
117	Then this initialises Gtk3.	1✔
118
119	=cut	1✔
120	fun _setup_gtk() {
121	_setup_disable_xinput2;
122	Gtk3::init;
123	}
124		×
125	fun _gtk_box_shim() {
126	my $shim = fun(@) {	×
127	my $orig = shift;
128	my $self = shift;
129	my $widget = shift;	×
130	if( $widget->can('_gtk_widget') ) {
131	$orig->($self, $widget->_gtk_widget, @_);
132	} else {
133	$orig->($self, $widget, @_);
134	}
135	};
136	for my $method (qw(pack_start add)) {
137	Class::Method::Modifiers::install_modifier
138	"Gtk3::Box",
139	around => $method => $shim;
140	}
141	}
142
143	sub import {
144	unless( $::LOADED ) {
145	_setup_gtk();
146	_scrolled_window_viewport_shim;
147	_gtk_box_shim;
148	#_set_theme('Flat-Plat');
149	#_set_icon_theme('Arc');
150	$::LOADED = 1;
151	}
152	return;
153	}
154
155	# Note: :prototype($$) would help here, but is only possible on Perl v5.20+
156
157	=classmethod C<gval>
158
159	classmethod gval( $glib_typename, $value )
160
161	Given a L<Glib type name\|https://developer.gnome.org/glib/stable/glib-Basic-Types.html>, wraps a
162	Perl value in an object that can be passed to other L<Glib>-based functions.
163
164
165	=begin :list
166
167	* C<$glib_typename>
168
169	The name of a type under the C<Glib::> namespace. For
170	example, passing in C<"int"> gives a wrapper to the C<gint>
171	C type which is known as C<Glib::Int> in Perl.
172
173	* C<$value>
174
175	The value to put inside the wrapper.
176
177	=end :list
178
179	See L<Glib::Object::Introspection::GValueWrapper> in
180	L<Glib::Object::Introspection> for more information.
181
182	=cut
183	classmethod gval( $glib_typename, $value ) { ## no critic
184	# GValue wrapper shortcut
185	Glib::Object::Introspection::GValueWrapper->new('Glib::'.ucfirst($glib_typename) => $value);
186	}
187
188	=classmethod genum
189
190	classmethod genum( $package, $sv )
191
192	Returns an enumeration value of type C<$package> which contains the matching
193	enum value given in C<$sv> as a string.
194
195	=begin :list
196
197	* C<$package>
198
199	The package name of a L<Glib> enumeration.
200
201	* C<$sv>
202
203	A string representation of the enumeration value.
204
205	=end :list
206
207	For example, for
208	L<GtkPackType\|https://developer.gnome.org/gtk3/stable/gtk3-Standard-Enumerations.html#GtkPackType>
209	enum, we set C<$package> to C<'Gtk3::PackType'> and C<$sv> to C<'GTK_PACK_START'>.
210	This can be passed on to other L<Glib::Object::Introspection> methods.
211
212	=cut
213	classmethod genum( $package, $sv ) {
214	Glib::Object::Introspection->convert_sv_to_enum($package, $sv);
215	}
216
217	=classmethod callback
218
219	classmethod callback( $invocant, $callback_name, @args )
220
221	A helper function to redirect to other callback functions. Given an
222	C<$invocant> and the name of the callback function, C<$callback_name>, which is
223	defined in the package of C<$invocant>, calls that function with arguments
224	C<( @args, $invocant )>.
225
226	For example, if we are trying to call the callback function
227	C<Target::Package::on_event_cb> and C<$target> is a blessed reference of type
228	C<Target::Package>, then by using
229
230	Renard::Incunabula::Frontend::Gtk3::Helper->callback( $target, on_event_cb => @rest_of_args );
231
232	effectively calls
233
234	Target::Package::on_event_cb( @rest_of_args, $target );
235
236
237	=cut
238	classmethod callback( $invocant, $callback_name, @args ) {
239	my $fun = $invocant->can( $callback_name );
240	$fun->( @args, $invocant );
241	}
242
243	1;

project-renard / p5-Renard-Incunabula-Frontend-Gtk3 / 33

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous