← Back to branch summary

~darkxst/ubuntu/saucy/gnome-shell/upstart_log

« back to all changes in this revision

Viewing changes to .pc/git-set-ally-wm-theme.patch/js/ui/status/accessibility.js

  • Committer: Package Import Robot
  • Author(s): Jeremy Bicha
  • Date: 2013-05-31 12:01:12 UTC
  • mfrom: (1.1.49) (19.1.36 experimental)
  • Revision ID: package-import@ubuntu.com-20130531120112-ew91khxf051x9i2r
Tags: 3.8.2-1ubuntu1
https://launchpad.net/bugs/1185869
https://launchpad.net/bugs/1185721
https://launchpad.net/bugs/1064584
* Merge with Debian (LP: #1185869, #1185721). Remaining changes:
  - debian/control.in:
    + Build-depend on libsystemd-login-dev & libsystemd-daemon-dev
    + Depend on gdm instead of gdm3
    + Don't recommend gnome-session-fallback
  - debian/patches/40_change-pam-name-to-match-gdm.patch:
  - debian/patches/revert-suspend-break.patch:
    + Disabled, not needed on Ubuntu
  - debian/patches/ubuntu-lightdm-user-switching.patch:
    + Allow user switching when using LightDM. Thanks Gerhard Stein
      for rebasing against gnome-shell 3.8!
  - debian/patches/ubuntu_lock_on_suspend.patch
    + Respect Ubuntu's lock-on-suspend setting.
      Disabled until it can be rewritten.
  - debian/patches/git_relock_screen_after_crash.patch:
    + Add Upstream fix for unlocked session after crash (LP: #1064584)
* Note that the new GNOME Classic mode (which requires installing
  gnome-shell-extensions) won't work until gnome-session 3.8 is
  available in Ubuntu

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/git-set-ally-wm-theme.patch/js/ui/status/accessibility.js
1
 
// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
2
 
 
3
 
const Gio = imports.gi.Gio;
4
 
const Lang = imports.lang;
5
 
 
6
 
const PanelMenu = imports.ui.panelMenu;
7
 
const PopupMenu = imports.ui.popupMenu;
8
 
 
9
 
const A11Y_SCHEMA = 'org.gnome.desktop.a11y.keyboard';
10
 
const KEY_STICKY_KEYS_ENABLED = 'stickykeys-enable';
11
 
const KEY_BOUNCE_KEYS_ENABLED = 'bouncekeys-enable';
12
 
const KEY_SLOW_KEYS_ENABLED   = 'slowkeys-enable';
13
 
const KEY_MOUSE_KEYS_ENABLED  = 'mousekeys-enable';
14
 
 
15
 
const APPLICATIONS_SCHEMA = 'org.gnome.desktop.a11y.applications';
16
 
 
17
 
const DPI_LOW_REASONABLE_VALUE  = 50;
18
 
const DPI_HIGH_REASONABLE_VALUE = 500;
19
 
 
20
 
const DPI_FACTOR_LARGE   = 1.25;
21
 
const DPI_FACTOR_LARGER  = 1.5;
22
 
const DPI_FACTOR_LARGEST = 2.0;
23
 
 
24
 
const WM_SCHEMA            = 'org.gnome.desktop.wm.preferences';
25
 
const KEY_VISUAL_BELL      = 'visual-bell';
26
 
 
27
 
const DESKTOP_INTERFACE_SCHEMA = 'org.gnome.desktop.interface';
28
 
const KEY_GTK_THEME      = 'gtk-theme';
29
 
const KEY_ICON_THEME     = 'icon-theme';
30
 
const KEY_TEXT_SCALING_FACTOR = 'text-scaling-factor';
31
 
 
32
 
const HIGH_CONTRAST_THEME = 'HighContrast';
33
 
 
34
 
const ATIndicator = new Lang.Class({
35
 
    Name: 'ATIndicator',
36
 
    Extends: PanelMenu.SystemStatusButton,
37
 
 
38
 
    _init: function() {
39
 
        this.parent('preferences-desktop-accessibility-symbolic', _("Accessibility"));
40
 
 
41
 
        let highContrast = this._buildHCItem();
42
 
        this.menu.addMenuItem(highContrast);
43
 
 
44
 
        let magnifier = this._buildItem(_("Zoom"), APPLICATIONS_SCHEMA,
45
 
                                                   'screen-magnifier-enabled');
46
 
        this.menu.addMenuItem(magnifier);
47
 
 
48
 
        let textZoom = this._buildFontItem();
49
 
        this.menu.addMenuItem(textZoom);
50
 
 
51
 
        let screenReader = this._buildItem(_("Screen Reader"), APPLICATIONS_SCHEMA,
52
 
                                                               'screen-reader-enabled');
53
 
        this.menu.addMenuItem(screenReader);
54
 
 
55
 
        let screenKeyboard = this._buildItem(_("Screen Keyboard"), APPLICATIONS_SCHEMA,
56
 
                                                                   'screen-keyboard-enabled');
57
 
        this.menu.addMenuItem(screenKeyboard);
58
 
 
59
 
        let visualBell = this._buildItem(_("Visual Alerts"), WM_SCHEMA, KEY_VISUAL_BELL);
60
 
        this.menu.addMenuItem(visualBell);
61
 
 
62
 
        let stickyKeys = this._buildItem(_("Sticky Keys"), A11Y_SCHEMA, KEY_STICKY_KEYS_ENABLED);
63
 
        this.menu.addMenuItem(stickyKeys);
64
 
 
65
 
        let slowKeys = this._buildItem(_("Slow Keys"), A11Y_SCHEMA, KEY_SLOW_KEYS_ENABLED);
66
 
        this.menu.addMenuItem(slowKeys);
67
 
 
68
 
        let bounceKeys = this._buildItem(_("Bounce Keys"), A11Y_SCHEMA, KEY_BOUNCE_KEYS_ENABLED);
69
 
        this.menu.addMenuItem(bounceKeys);
70
 
 
71
 
        let mouseKeys = this._buildItem(_("Mouse Keys"), A11Y_SCHEMA, KEY_MOUSE_KEYS_ENABLED);
72
 
        this.menu.addMenuItem(mouseKeys);
73
 
 
74
 
        this.menu.addMenuItem(new PopupMenu.PopupSeparatorMenuItem());
75
 
        this.menu.addSettingsAction(_("Universal Access Settings"), 'gnome-universal-access-panel.desktop');
76
 
    },
77
 
 
78
 
    _buildItemExtended: function(string, initial_value, writable, on_set) {
79
 
        let widget = new PopupMenu.PopupSwitchMenuItem(string, initial_value);
80
 
        if (!writable)
81
 
            widget.actor.reactive = false;
82
 
        else
83
 
            widget.connect('toggled', function(item) {
84
 
                on_set(item.state);
85
 
            });
86
 
        return widget;
87
 
    },
88
 
 
89
 
    _buildItem: function(string, schema, key) {
90
 
        let settings = new Gio.Settings({ schema: schema });
91
 
        let widget = this._buildItemExtended(string,
92
 
            settings.get_boolean(key),
93
 
            settings.is_writable(key),
94
 
            function(enabled) {
95
 
                return settings.set_boolean(key, enabled);
96
 
            });
97
 
        settings.connect('changed::'+key, function() {
98
 
            widget.setToggleState(settings.get_boolean(key));
99
 
        });
100
 
        return widget;
101
 
    },
102
 
 
103
 
    _buildHCItem: function() {
104
 
        let settings = new Gio.Settings({ schema: DESKTOP_INTERFACE_SCHEMA });
105
 
        let gtkTheme = settings.get_string(KEY_GTK_THEME);
106
 
        let iconTheme = settings.get_string(KEY_ICON_THEME);
107
 
        let hasHC = (gtkTheme == HIGH_CONTRAST_THEME);
108
 
        let highContrast = this._buildItemExtended(
109
 
            _("High Contrast"),
110
 
            hasHC,
111
 
            settings.is_writable(KEY_GTK_THEME) && settings.is_writable(KEY_ICON_THEME),
112
 
            function (enabled) {
113
 
                if (enabled) {
114
 
                    settings.set_string(KEY_GTK_THEME, HIGH_CONTRAST_THEME);
115
 
                    settings.set_string(KEY_ICON_THEME, HIGH_CONTRAST_THEME);
116
 
                } else if(!hasHC) {
117
 
                    settings.set_string(KEY_GTK_THEME, gtkTheme);
118
 
                    settings.set_string(KEY_ICON_THEME, iconTheme);
119
 
                } else {
120
 
                    settings.reset(KEY_GTK_THEME);
121
 
                    settings.reset(KEY_ICON_THEME);
122
 
                }
123
 
            });
124
 
        settings.connect('changed::' + KEY_GTK_THEME, function() {
125
 
            let value = settings.get_string(KEY_GTK_THEME);
126
 
            if (value == HIGH_CONTRAST_THEME) {
127
 
                highContrast.setToggleState(true);
128
 
            } else {
129
 
                highContrast.setToggleState(false);
130
 
                gtkTheme = value;
131
 
            }
132
 
        });
133
 
        settings.connect('changed::' + KEY_ICON_THEME, function() {
134
 
            let value = settings.get_string(KEY_ICON_THEME);
135
 
            if (value != HIGH_CONTRAST_THEME)
136
 
                iconTheme = value;
137
 
        });
138
 
        return highContrast;
139
 
    },
140
 
 
141
 
    _buildFontItem: function() {
142
 
        let settings = new Gio.Settings({ schema: DESKTOP_INTERFACE_SCHEMA });
143
 
 
144
 
        let factor = settings.get_double(KEY_TEXT_SCALING_FACTOR);
145
 
        let initial_setting = (factor > 1.0);
146
 
        let widget = this._buildItemExtended(_("Large Text"),
147
 
            initial_setting,
148
 
            settings.is_writable(KEY_TEXT_SCALING_FACTOR),
149
 
            function (enabled) {
150
 
                if (enabled)
151
 
                    settings.set_double(KEY_TEXT_SCALING_FACTOR,
152
 
                                        DPI_FACTOR_LARGE);
153
 
                else
154
 
                    settings.reset(KEY_TEXT_SCALING_FACTOR);
155
 
            });
156
 
        settings.connect('changed::' + KEY_TEXT_SCALING_FACTOR, function() {
157
 
            let factor = settings.get_double(KEY_TEXT_SCALING_FACTOR);
158
 
            let active = (factor > 1.0);
159
 
            widget.setToggleState(active);
160
 
        });
161
 
        return widget;
162
 
    }
163
 
});