GCC Code Coverage Report

Directory:	./
File:	panels/universal-access/cc-ua-typing-page.c
Date:	2024-05-04 07:58:27

	Total	Coverage
Lines:	94	0.0%
Functions:	9	0.0%
Branches:	23	0.0%

  
      Line
      Branch
      Exec
      Source
    
      /* -*- mode: c; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
    
       *
    
       * Copyright (C) 2008 William Jon McCann <jmccann@redhat.com>
    
       * Copyright (C) 2010 Intel, Inc
    
       * Copyright 2022 Mohammed Sadiq <sadiq@sadiqpk.org>
    
       * Copyright 2022 Purism SPC
    
       *
    
       * Licensed under the GNU General Public License Version 2
    
       *
    
       * This program is free software; you can redistribute it and/or modify
    
       * it under the terms of the GNU General Public License as published by
    
       * the Free Software Foundation; either version 2 of the License, or
    
       * (at your option) any later version.
    
       *
    
       * This program is distributed in the hope that it will be useful,
    
       * but WITHOUT ANY WARRANTY; without even the implied warranty of
    
       * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    
       * GNU General Public License for more details.
    
       *
    
       * You should have received a copy of the GNU General Public License
    
       * along with this program; if not, write to the Free Software
    
       * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
    
       *
    
       * Author(s):
    
       *   Thomas Wood <thomas.wood@intel.com>
    
       *   Rodrigo Moya <rodrigo@gnome.org>
    
       *   Mohammed Sadiq <sadiq@sadiqpk.org>
    
       *
    
       * SPDX-License-Identifier: GPL-2.0-or-later
    
       */
    
      #undef G_LOG_DOMAIN
    
      #define G_LOG_DOMAIN "cc-ua-typing-page"
    
      #ifdef HAVE_CONFIG_H
    
      # include "config.h"
    
      #endif
    
      #include <gdesktop-enums.h>
    
      #include "cc-ua-macros.h"
    
      #include "cc-ua-typing-page.h"
    
      struct _CcUaTypingPage
    
      {
    
        AdwNavigationPage   parent_instance;
    
        AdwSwitchRow       *screen_kb_row;
    
        AdwSwitchRow       *shortcuts_by_kb_row;
    
        AdwSwitchRow       *cursor_blink_row;
    
        GtkScale           *blink_time_scale;
    
        AdwComboRow        *flash_type_row;
    
        AdwExpanderRow     *repeat_keys_row;
    
        GtkScale           *repeat_speed_scale;
    
        GtkScale           *repeat_delay_scale;
    
        AdwExpanderRow     *sticky_keys_row;
    
        AdwSwitchRow       *disable_sticky_keys_row;
    
        AdwSwitchRow       *beep_sticky_keys_row;
    
        AdwExpanderRow     *slow_keys_row;
    
        GtkScale           *slow_keys_delay_scale;
    
        AdwSwitchRow       *slow_keys_beep_row;
    
        AdwSwitchRow       *slow_keys_beep_accept_row;
    
        AdwSwitchRow       *slow_keys_beep_reject_row;
    
        AdwExpanderRow     *bounce_keys_row;
    
        GtkScale           *bounce_keys_delay_scale;
    
        AdwSwitchRow       *bounce_keys_beep_reject_row;
    
        GSettings          *application_settings;
    
        GSettings          *interface_settings;
    
        GSettings          *kb_desktop_settings;
    
        GSettings          *kb_settings;
    
      };
    
      ✗
      G_DEFINE_TYPE (CcUaTypingPage, cc_ua_typing_page, ADW_TYPE_NAVIGATION_PAGE)
    
      /*
    
       * In the UI We are showing the speed, but in the settings we
    
       * are storing the duration.  So we want to show the inverse
    
       * of the value.  But since GtkAdjustment doesn't allow
    
       * upper < lower, and GtkRange:inverted is not what we need,
    
       * use negative values for lower, upper bounds and invert sign
    
       * of them when read/write.
    
       */
    
      static gboolean
    
      ✗
      get_inverted_mapping (GValue   *value,
    
                            GVariant *variant,
    
                            gpointer  user_data)
    
      {
    
        const GVariantType *type;
    
        gint64 val;
    
      ✗
        type = g_variant_get_type (variant);
    
      ✗
        if (g_variant_type_equal (type, G_VARIANT_TYPE_INT32))
    
      ✗
          val = g_variant_get_int32 (variant);
    
      ✗
        else if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT32))
    
      ✗
          val = g_variant_get_uint32 (variant);
    
        else
    
      ✗
          return FALSE;
    
      ✗
        g_value_set_double (value, val * - 1);
    
      ✗
        return TRUE;
    
      }
    
      static GVariant *
    
      ✗
      set_inverted_mapping (const GValue       *value,
    
                            const GVariantType *expected_type,
    
                            gpointer            user_data)
    
      {
    
        int val;
    
        /* in UI, we show speed from slow to fast, but we store the time, not speed */
    
      ✗
        val = (int)g_value_get_double (value);
    
      ✗
        if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT32))
    
      ✗
          return g_variant_new_int32 (val * -1);
    
      ✗
        if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT32))
    
      ✗
          return g_variant_new_uint32 (val * -1);
    
      ✗
        return NULL;
    
      }
    
      static void
    
      ✗
      bind_scale_with_mapping (CcUaTypingPage *self,
    
                               GSettings      *settings,
    
                               const char     *settings_key,
    
                               GtkScale       *scale)
    
      {
    
        GtkAdjustment *adj;
    
      ✗
        adj = gtk_range_get_adjustment (GTK_RANGE (scale));
    
      ✗
        g_settings_bind_with_mapping (settings, settings_key,
    
                                      adj, "value",
    
                                      G_SETTINGS_BIND_DEFAULT,
    
                                      get_inverted_mapping,
    
                                      set_inverted_mapping,
    
                                      self, NULL);
    
      ✗
      }
    
      static void
    
      ✗
      cc_ua_typing_page_dispose (GObject *object)
    
      {
    
      ✗
        CcUaTypingPage *self = (CcUaTypingPage *)object;
    
      ✗
        g_clear_object (&self->application_settings);
    
      ✗
        g_clear_object (&self->interface_settings);
    
      ✗
        g_clear_object (&self->kb_desktop_settings);
    
      ✗
        g_clear_object (&self->kb_settings);
    
      ✗
        G_OBJECT_CLASS (cc_ua_typing_page_parent_class)->dispose (object);
    
      ✗
      }
    
      static void
    
      ✗
      cc_ua_typing_page_class_init (CcUaTypingPageClass *klass)
    
      {
    
      ✗
        GObjectClass *object_class = G_OBJECT_CLASS (klass);
    
      ✗
        GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
    
      ✗
        object_class->dispose = cc_ua_typing_page_dispose;
    
      ✗
        gtk_widget_class_set_template_from_resource (widget_class,
    
                                                     "/org/gnome/control-center/"
    
                                                     "universal-access/cc-ua-typing-page.ui");
    
      ✗
        gtk_widget_class_bind_template_child (widget_class, CcUaTypingPage, screen_kb_row);
    
      ✗
        gtk_widget_class_bind_template_child (widget_class, CcUaTypingPage, shortcuts_by_kb_row);
    
      ✗
        gtk_widget_class_bind_template_child (widget_class, CcUaTypingPage, cursor_blink_row);
    
      ✗
        gtk_widget_class_bind_template_child (widget_class, CcUaTypingPage, blink_time_scale);
    
      ✗
        gtk_widget_class_bind_template_child (widget_class, CcUaTypingPage, repeat_keys_row);
    
      ✗
        gtk_widget_class_bind_template_child (widget_class, CcUaTypingPage, repeat_speed_scale);
    
      ✗
        gtk_widget_class_bind_template_child (widget_class, CcUaTypingPage, repeat_delay_scale);
    
      ✗
        gtk_widget_class_bind_template_child (widget_class, CcUaTypingPage, sticky_keys_row);
    
      ✗
        gtk_widget_class_bind_template_child (widget_class, CcUaTypingPage, disable_sticky_keys_row);
    
      ✗
        gtk_widget_class_bind_template_child (widget_class, CcUaTypingPage, beep_sticky_keys_row);
    
      ✗
        gtk_widget_class_bind_template_child (widget_class, CcUaTypingPage, slow_keys_row);
    
      ✗
        gtk_widget_class_bind_template_child (widget_class, CcUaTypingPage, slow_keys_delay_scale);
    
      ✗
        gtk_widget_class_bind_template_child (widget_class, CcUaTypingPage, slow_keys_beep_row);
    
      ✗
        gtk_widget_class_bind_template_child (widget_class, CcUaTypingPage, slow_keys_beep_accept_row);
    
      ✗
        gtk_widget_class_bind_template_child (widget_class, CcUaTypingPage, slow_keys_beep_reject_row);
    
      ✗
        gtk_widget_class_bind_template_child (widget_class, CcUaTypingPage, bounce_keys_row);
    
      ✗
        gtk_widget_class_bind_template_child (widget_class, CcUaTypingPage, bounce_keys_delay_scale);
    
      ✗
        gtk_widget_class_bind_template_child (widget_class, CcUaTypingPage, bounce_keys_beep_reject_row);
    
      ✗
      }
    
      static void
    
      ✗
      cc_ua_typing_page_init (CcUaTypingPage *self)
    
      {
    
      ✗
        gtk_widget_init_template (GTK_WIDGET (self));
    
      ✗
        self->application_settings = g_settings_new (APPLICATION_SETTINGS);
    
      ✗
        self->interface_settings = g_settings_new (INTERFACE_SETTINGS);
    
      ✗
        self->kb_desktop_settings = g_settings_new (KEYBOARD_DESKTOP_SETTINGS);
    
      ✗
        self->kb_settings = g_settings_new (KEYBOARD_SETTINGS);
    
      ✗
        g_settings_bind (self->application_settings, KEY_SCREEN_KEYBOARD_ENABLED,
    
      ✗
                         self->screen_kb_row, "active",
    
                         G_SETTINGS_BIND_DEFAULT);
    
      ✗
        g_settings_bind (self->kb_settings, KEY_KEYBOARD_TOGGLE,
    
      ✗
                         self->shortcuts_by_kb_row, "active",
    
                         G_SETTINGS_BIND_DEFAULT);
    
        /* Text Cursor */
    
      ✗
        g_settings_bind (self->interface_settings, KEY_CURSOR_BLINKING,
    
      ✗
                         self->cursor_blink_row, "active",
    
                         G_SETTINGS_BIND_DEFAULT);
    
      ✗
        bind_scale_with_mapping (self, self->interface_settings,
    
                                 KEY_CURSOR_BLINKING_TIME,
    
                                 self->blink_time_scale);
    
        /* Repeat keys */
    
      ✗
        g_settings_bind (self->kb_desktop_settings, KEY_REPEAT_KEYS,
    
      ✗
                         self->repeat_keys_row, "enable-expansion",
    
                         G_SETTINGS_BIND_DEFAULT);
    
      ✗
        bind_scale_with_mapping (self, self->kb_desktop_settings,
    
                                 KEY_REPEAT_INTERVAL,
    
                                 self->repeat_speed_scale);
    
      ✗
        g_settings_bind (self->kb_desktop_settings, KEY_REPEAT_DELAY,
    
      ✗
                         gtk_range_get_adjustment (GTK_RANGE (self->repeat_delay_scale)), "value",
    
                         G_SETTINGS_BIND_DEFAULT);
    
        /* Sticky keys */
    
      ✗
        g_settings_bind (self->kb_settings, KEY_STICKYKEYS_ENABLED,
    
      ✗
                         self->sticky_keys_row, "enable-expansion",
    
                         G_SETTINGS_BIND_DEFAULT);
    
      ✗
        g_settings_bind (self->kb_settings, KEY_STICKYKEYS_TWO_KEY_OFF,
    
      ✗
                         self->disable_sticky_keys_row, "active",
    
                         G_SETTINGS_BIND_DEFAULT);
    
      ✗
        g_settings_bind (self->kb_settings, KEY_STICKYKEYS_MODIFIER_BEEP,
    
      ✗
                         self->beep_sticky_keys_row, "active",
    
                         G_SETTINGS_BIND_NO_SENSITIVITY);
    
        /* Slow Keys */
    
      ✗
        g_settings_bind (self->kb_settings, KEY_SLOWKEYS_ENABLED,
    
      ✗
                         self->slow_keys_row, "enable-expansion",
    
                         G_SETTINGS_BIND_DEFAULT);
    
      ✗
        g_settings_bind (self->kb_settings, KEY_SLOWKEYS_DELAY,
    
      ✗
                         gtk_range_get_adjustment (GTK_RANGE (self->slow_keys_delay_scale)), "value",
    
                         G_SETTINGS_BIND_DEFAULT);
    
      ✗
        g_settings_bind (self->kb_settings, KEY_SLOWKEYS_BEEP_PRESS,
    
      ✗
                         self->slow_keys_beep_row, "active",
    
                         G_SETTINGS_BIND_DEFAULT);
    
      ✗
        g_settings_bind (self->kb_settings, KEY_SLOWKEYS_BEEP_ACCEPT,
    
      ✗
                         self->slow_keys_beep_accept_row, "active",
    
                         G_SETTINGS_BIND_DEFAULT);
    
      ✗
        g_settings_bind (self->kb_settings, KEY_SLOWKEYS_BEEP_REJECT,
    
      ✗
                         self->slow_keys_beep_reject_row, "active",
    
                         G_SETTINGS_BIND_DEFAULT);
    
        /* Bounce Keys */
    
      ✗
        g_settings_bind (self->kb_settings, KEY_BOUNCEKEYS_ENABLED,
    
      ✗
                         self->bounce_keys_row, "enable-expansion",
    
                         G_SETTINGS_BIND_DEFAULT);
    
      ✗
        g_settings_bind (self->kb_settings, KEY_BOUNCEKEYS_DELAY,
    
      ✗
                         gtk_range_get_adjustment (GTK_RANGE (self->bounce_keys_delay_scale)), "value",
    
                         G_SETTINGS_BIND_DEFAULT);
    
      ✗
        g_settings_bind (self->kb_settings, KEY_BOUNCEKEYS_BEEP_REJECT,
    
      ✗
                         self->bounce_keys_beep_reject_row, "active",
    
                         G_SETTINGS_BIND_NO_SENSITIVITY);
    
      ✗
      }

Line	Exec	Source
1		/* -- mode: c; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 --
2		*
3		* Copyright (C) 2008 William Jon McCann <jmccann@redhat.com>
4		* Copyright (C) 2010 Intel, Inc
5		* Copyright 2022 Mohammed Sadiq <sadiq@sadiqpk.org>
6		* Copyright 2022 Purism SPC
7		*
8		* Licensed under the GNU General Public License Version 2
9		*
10		* This program is free software; you can redistribute it and/or modify
11		* it under the terms of the GNU General Public License as published by
12		* the Free Software Foundation; either version 2 of the License, or
13		* (at your option) any later version.
14		*
15		* This program is distributed in the hope that it will be useful,
16		* but WITHOUT ANY WARRANTY; without even the implied warranty of
17		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18		* GNU General Public License for more details.
19		*
20		* You should have received a copy of the GNU General Public License
21		* along with this program; if not, write to the Free Software
22		* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
23		*
24		* Author(s):
25		* Thomas Wood <thomas.wood@intel.com>
26		* Rodrigo Moya <rodrigo@gnome.org>
27		* Mohammed Sadiq <sadiq@sadiqpk.org>
28		*
29		* SPDX-License-Identifier: GPL-2.0-or-later
30		*/
31
32		#undef G_LOG_DOMAIN
33		#define G_LOG_DOMAIN "cc-ua-typing-page"
34
35		#ifdef HAVE_CONFIG_H
36		# include "config.h"
37		#endif
38
39		#include <gdesktop-enums.h>
40
41		#include "cc-ua-macros.h"
42		#include "cc-ua-typing-page.h"
43
44		struct _CcUaTypingPage
45		{
46		AdwNavigationPage parent_instance;
47
48		AdwSwitchRow *screen_kb_row;
49		AdwSwitchRow *shortcuts_by_kb_row;
50
51		AdwSwitchRow *cursor_blink_row;
52		GtkScale *blink_time_scale;
53		AdwComboRow *flash_type_row;
54
55		AdwExpanderRow *repeat_keys_row;
56		GtkScale *repeat_speed_scale;
57		GtkScale *repeat_delay_scale;
58
59		AdwExpanderRow *sticky_keys_row;
60		AdwSwitchRow *disable_sticky_keys_row;
61		AdwSwitchRow *beep_sticky_keys_row;
62
63		AdwExpanderRow *slow_keys_row;
64		GtkScale *slow_keys_delay_scale;
65		AdwSwitchRow *slow_keys_beep_row;
66		AdwSwitchRow *slow_keys_beep_accept_row;
67		AdwSwitchRow *slow_keys_beep_reject_row;
68
69		AdwExpanderRow *bounce_keys_row;
70		GtkScale *bounce_keys_delay_scale;
71		AdwSwitchRow *bounce_keys_beep_reject_row;
72
73		GSettings *application_settings;
74		GSettings *interface_settings;
75		GSettings *kb_desktop_settings;
76		GSettings *kb_settings;
77		};
78
79	✗	G_DEFINE_TYPE (CcUaTypingPage, cc_ua_typing_page, ADW_TYPE_NAVIGATION_PAGE)
80
81		/*
82		* In the UI We are showing the speed, but in the settings we
83		* are storing the duration. So we want to show the inverse
84		* of the value. But since GtkAdjustment doesn't allow
85		* upper < lower, and GtkRange:inverted is not what we need,
86		* use negative values for lower, upper bounds and invert sign
87		* of them when read/write.
88		*/
89		static gboolean
90	✗	get_inverted_mapping (GValue *value,
91		GVariant *variant,
92		gpointer user_data)
93		{
94		const GVariantType *type;
95		gint64 val;
96
97	✗	type = g_variant_get_type (variant);
98
99	✗	if (g_variant_type_equal (type, G_VARIANT_TYPE_INT32))
100	✗	val = g_variant_get_int32 (variant);
101	✗	else if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT32))
102	✗	val = g_variant_get_uint32 (variant);
103		else
104	✗	return FALSE;
105
106	✗	g_value_set_double (value, val * - 1);
107
108	✗	return TRUE;
109		}
110
111		static GVariant *
112	✗	set_inverted_mapping (const GValue *value,
113		const GVariantType *expected_type,
114		gpointer user_data)
115		{
116		int val;
117
118		/* in UI, we show speed from slow to fast, but we store the time, not speed */
119	✗	val = (int)g_value_get_double (value);
120
121	✗	if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT32))
122	✗	return g_variant_new_int32 (val * -1);
123
124	✗	if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT32))
125	✗	return g_variant_new_uint32 (val * -1);
126
127	✗	return NULL;
128		}
129
130		static void
131	✗	bind_scale_with_mapping (CcUaTypingPage *self,
132		GSettings *settings,
133		const char *settings_key,
134		GtkScale *scale)
135		{
136		GtkAdjustment *adj;
137
138	✗	adj = gtk_range_get_adjustment (GTK_RANGE (scale));
139
140	✗	g_settings_bind_with_mapping (settings, settings_key,
141		adj, "value",
142		G_SETTINGS_BIND_DEFAULT,
143		get_inverted_mapping,
144		set_inverted_mapping,
145		self, NULL);
146	✗	}
147
148		static void
149	✗	cc_ua_typing_page_dispose (GObject *object)
150		{
151	✗	CcUaTypingPage self = (CcUaTypingPage )object;
152
153	✗	g_clear_object (&self->application_settings);
154	✗	g_clear_object (&self->interface_settings);
155	✗	g_clear_object (&self->kb_desktop_settings);
156	✗	g_clear_object (&self->kb_settings);
157
158	✗	G_OBJECT_CLASS (cc_ua_typing_page_parent_class)->dispose (object);
159	✗	}
160
161		static void
162	✗	cc_ua_typing_page_class_init (CcUaTypingPageClass *klass)
163		{
164	✗	GObjectClass *object_class = G_OBJECT_CLASS (klass);
165	✗	GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
166
167	✗	object_class->dispose = cc_ua_typing_page_dispose;
168
169	✗	gtk_widget_class_set_template_from_resource (widget_class,
170		"/org/gnome/control-center/"
171		"universal-access/cc-ua-typing-page.ui");
172
173	✗	gtk_widget_class_bind_template_child (widget_class, CcUaTypingPage, screen_kb_row);
174	✗	gtk_widget_class_bind_template_child (widget_class, CcUaTypingPage, shortcuts_by_kb_row);
175
176	✗	gtk_widget_class_bind_template_child (widget_class, CcUaTypingPage, cursor_blink_row);
177	✗	gtk_widget_class_bind_template_child (widget_class, CcUaTypingPage, blink_time_scale);
178
179	✗	gtk_widget_class_bind_template_child (widget_class, CcUaTypingPage, repeat_keys_row);
180	✗	gtk_widget_class_bind_template_child (widget_class, CcUaTypingPage, repeat_speed_scale);
181	✗	gtk_widget_class_bind_template_child (widget_class, CcUaTypingPage, repeat_delay_scale);
182
183	✗	gtk_widget_class_bind_template_child (widget_class, CcUaTypingPage, sticky_keys_row);
184	✗	gtk_widget_class_bind_template_child (widget_class, CcUaTypingPage, disable_sticky_keys_row);
185	✗	gtk_widget_class_bind_template_child (widget_class, CcUaTypingPage, beep_sticky_keys_row);
186
187	✗	gtk_widget_class_bind_template_child (widget_class, CcUaTypingPage, slow_keys_row);
188	✗	gtk_widget_class_bind_template_child (widget_class, CcUaTypingPage, slow_keys_delay_scale);
189	✗	gtk_widget_class_bind_template_child (widget_class, CcUaTypingPage, slow_keys_beep_row);
190	✗	gtk_widget_class_bind_template_child (widget_class, CcUaTypingPage, slow_keys_beep_accept_row);
191	✗	gtk_widget_class_bind_template_child (widget_class, CcUaTypingPage, slow_keys_beep_reject_row);
192
193	✗	gtk_widget_class_bind_template_child (widget_class, CcUaTypingPage, bounce_keys_row);
194	✗	gtk_widget_class_bind_template_child (widget_class, CcUaTypingPage, bounce_keys_delay_scale);
195	✗	gtk_widget_class_bind_template_child (widget_class, CcUaTypingPage, bounce_keys_beep_reject_row);
196	✗	}
197
198		static void
199	✗	cc_ua_typing_page_init (CcUaTypingPage *self)
200		{
201	✗	gtk_widget_init_template (GTK_WIDGET (self));
202
203	✗	self->application_settings = g_settings_new (APPLICATION_SETTINGS);
204	✗	self->interface_settings = g_settings_new (INTERFACE_SETTINGS);
205	✗	self->kb_desktop_settings = g_settings_new (KEYBOARD_DESKTOP_SETTINGS);
206	✗	self->kb_settings = g_settings_new (KEYBOARD_SETTINGS);
207
208	✗	g_settings_bind (self->application_settings, KEY_SCREEN_KEYBOARD_ENABLED,
209	✗	self->screen_kb_row, "active",
210		G_SETTINGS_BIND_DEFAULT);
211	✗	g_settings_bind (self->kb_settings, KEY_KEYBOARD_TOGGLE,
212	✗	self->shortcuts_by_kb_row, "active",
213		G_SETTINGS_BIND_DEFAULT);
214
215		/* Text Cursor */
216	✗	g_settings_bind (self->interface_settings, KEY_CURSOR_BLINKING,
217	✗	self->cursor_blink_row, "active",
218		G_SETTINGS_BIND_DEFAULT);
219	✗	bind_scale_with_mapping (self, self->interface_settings,
220		KEY_CURSOR_BLINKING_TIME,
221		self->blink_time_scale);
222
223		/* Repeat keys */
224	✗	g_settings_bind (self->kb_desktop_settings, KEY_REPEAT_KEYS,
225	✗	self->repeat_keys_row, "enable-expansion",
226		G_SETTINGS_BIND_DEFAULT);
227
228	✗	bind_scale_with_mapping (self, self->kb_desktop_settings,
229		KEY_REPEAT_INTERVAL,
230		self->repeat_speed_scale);
231	✗	g_settings_bind (self->kb_desktop_settings, KEY_REPEAT_DELAY,
232	✗	gtk_range_get_adjustment (GTK_RANGE (self->repeat_delay_scale)), "value",
233		G_SETTINGS_BIND_DEFAULT);
234
235		/* Sticky keys */
236	✗	g_settings_bind (self->kb_settings, KEY_STICKYKEYS_ENABLED,
237	✗	self->sticky_keys_row, "enable-expansion",
238		G_SETTINGS_BIND_DEFAULT);
239	✗	g_settings_bind (self->kb_settings, KEY_STICKYKEYS_TWO_KEY_OFF,
240	✗	self->disable_sticky_keys_row, "active",
241		G_SETTINGS_BIND_DEFAULT);
242	✗	g_settings_bind (self->kb_settings, KEY_STICKYKEYS_MODIFIER_BEEP,
243	✗	self->beep_sticky_keys_row, "active",
244		G_SETTINGS_BIND_NO_SENSITIVITY);
245
246		/* Slow Keys */
247	✗	g_settings_bind (self->kb_settings, KEY_SLOWKEYS_ENABLED,
248	✗	self->slow_keys_row, "enable-expansion",
249		G_SETTINGS_BIND_DEFAULT);
250	✗	g_settings_bind (self->kb_settings, KEY_SLOWKEYS_DELAY,
251	✗	gtk_range_get_adjustment (GTK_RANGE (self->slow_keys_delay_scale)), "value",
252		G_SETTINGS_BIND_DEFAULT);
253	✗	g_settings_bind (self->kb_settings, KEY_SLOWKEYS_BEEP_PRESS,
254	✗	self->slow_keys_beep_row, "active",
255		G_SETTINGS_BIND_DEFAULT);
256	✗	g_settings_bind (self->kb_settings, KEY_SLOWKEYS_BEEP_ACCEPT,
257	✗	self->slow_keys_beep_accept_row, "active",
258		G_SETTINGS_BIND_DEFAULT);
259	✗	g_settings_bind (self->kb_settings, KEY_SLOWKEYS_BEEP_REJECT,
260	✗	self->slow_keys_beep_reject_row, "active",
261		G_SETTINGS_BIND_DEFAULT);
262
263		/* Bounce Keys */
264	✗	g_settings_bind (self->kb_settings, KEY_BOUNCEKEYS_ENABLED,
265	✗	self->bounce_keys_row, "enable-expansion",
266		G_SETTINGS_BIND_DEFAULT);
267	✗	g_settings_bind (self->kb_settings, KEY_BOUNCEKEYS_DELAY,
268	✗	gtk_range_get_adjustment (GTK_RANGE (self->bounce_keys_delay_scale)), "value",
269		G_SETTINGS_BIND_DEFAULT);
270	✗	g_settings_bind (self->kb_settings, KEY_BOUNCEKEYS_BEEP_REJECT,
271	✗	self->bounce_keys_beep_reject_row, "active",
272		G_SETTINGS_BIND_NO_SENSITIVITY);
273	✗	}
274