cromer/tuf-manager
1
0
Fork 0
Code Issues Pull Requests Releases 8 Wiki Activity

initial commit

Browse Source
This commit is contained in:
Chris Cromer
2020-08-04 23:09:05 -04:00
commit fecee5afab
55 changed files with 2784 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

299
src/cli.vala Normal file
View File

@@ -0,0 +1,299 @@
/*
* Copyright 2020 Chris Cromer
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/**
* The TUF Manager namespace
*/
namespace TUFManager {
/**
* The CLI namespace handles all command line related usage
*/
namespace CLI {
public class TUFManagerApp : Application {
#if ALWAYS_AUTHENTICATED
#else
/**
* The subprocess that will contain our tty polkit agent
*/
Subprocess? pkttyagent = null;
#endif
private enum FanMode {
BALANCED,
TURBO,
SILENT
}
private enum KeyboardMode {
STATIC,
BREATHING,
COLOR_CYCLE,
STROBING
}
private enum KeyboardSpeed {
SLOW,
MEDIUM,
FAST
}
private bool invalid = false;
private bool help = false;
private bool info = false;
private bool version = false;
private bool fan = false;
private FanMode? fan_mode = null;
private bool lighting;
private KeyboardMode? keyboard_mode = null;
public TUFManagerApp () {
Object (application_id: "cl.cromer.tuf.manager", flags: ApplicationFlags.HANDLES_COMMAND_LINE);
set_inactivity_timeout (1000);
}
public override void activate () {
this.hold ();
this.release ();
}
private int _command_line (ApplicationCommandLine command_line) {
try {
connect_dbus ();
}
catch (TUFError e) {
command_line.printerr ("Error: " + e.message + "\n");
}
string[] args = command_line.get_arguments ();
// tuf-cli fan silent
// tuf-cli color #FFFFFF
// tuf-cli lighting strobe
// tuf-cli help
// tuf-cli info
// tuf-cli version
// same as info // tuf-cli
if (args.length == 1) {
help = true;
}
else if (args.length > 1) {
switch (args[1]) {
case "version":
version = true;
check_second_argument (args);
break;
case "help":
help = true;
check_second_argument (args);
break;
case "info":
info = true;
check_second_argument (args);
break;
case "fan":
fan = true;
break;
case "lighting":
lighting = true;
break;
default:
invalid = true;
break;
}
if (args.length > 2) {
if (fan) {
switch (args[2]) {
case "balanced":
fan_mode = FanMode.BALANCED;
break;
case "turbo":
fan_mode = FanMode.TURBO;
break;
case "silent":
fan_mode = FanMode.SILENT;
break;
default:
invalid = true;
break;
}
}
if (lighting) {
switch (args[2]) {
case "static":
keyboard_mode = KeyboardMode.STATIC;
break;
case "breath":
keyboard_mode = KeyboardMode.BREATHING;
break;
case "cycle":
keyboard_mode = KeyboardMode.COLOR_CYCLE;
break;
case "strobe":
keyboard_mode = KeyboardMode.STROBING;
break;
default:
invalid = true;
break;
}
}
}
}
if (invalid) {
command_line.printerr (_ ("Invalid arguments!\n"));
print_usage (command_line);
release_cli ();
return 1;
}
else if (version) {
command_line.print (_ ("Version: ") + VERSION + "\n");
release_cli ();
return 0;
}
else if (help) {
print_usage (command_line);
release_cli ();
return 0;
}
else if (info) {
command_line.print (_ ("Client version: ") + VERSION + "\n");
command_line.print (_ ("Server version: ") + get_server_version () + "\n");
var mode = get_fan_mode ();
switch (mode) {
case 0:
command_line.print (_ ("Current fan mode: Balanced\n"));
break;
case 1:
command_line.print (_ ("Current fan mode: Turbo\n"));
break;
case 2:
command_line.print (_ ("Current fan mode: Silent\n"));
break;
default:
command_line.printerr (_ ("Error: Could not get current fan mode!\n"));
break;
}
mode = get_keyboard_mode ();
switch (mode) {
case 0:
command_line.print (_ ("Current keyboard lighting: Static\n"));
break;
case 1:
command_line.print (_ ("Current keyboard lighting: Breathing\n"));
break;
case 2:
command_line.print (_ ("Current keyboard lighting: Color Cycle\n"));
break;
case 3:
command_line.print (_ ("Current keyboard lighting: Strobing\n"));
break;
default:
command_line.printerr (_ ("Error: Could not get current fan mode!\n"));
break;
}
release_cli ();
return 0;
}
else if (fan) {
#if ALWAYS_AUTHENTICATED
int mode = fan_mode;
tuf_server.procedure_finished.connect (release_cli);
set_fan_mode (mode);
#else
try {
pkttyagent = new Subprocess.newv ({"pkttyagent"}, SubprocessFlags.NONE);
Timeout.add (200, () => {
int mode = fan_mode;
tuf_server.procedure_finished.connect (release_cli);
set_fan_mode (mode);
return false;
});
}
catch (Error e) {
command_line.printerr ("Error: " + e.message + "\n");
}
#endif
return 0;
}
else if (lighting) {
#if ALWAYS_AUTHENTICATED
int mode = keyboard_mode;
tuf_server.procedure_finished.connect (release_cli);
set_keyboard_mode (mode);
#else
try {
pkttyagent = new Subprocess.newv ({"pkttyagent"}, SubprocessFlags.NONE);
Timeout.add (200, () => {
int mode = keyboard_mode;
tuf_server.procedure_finished.connect (release_cli);
set_keyboard_mode (mode);
return false;
});
}
catch (Error e) {
command_line.printerr ("Error: " + e.message + "\n");
}
#endif
return 0;
}
return 0;
}
private void check_second_argument (string[] args) {
if (args.length > 2) {
invalid = true;
}
}
private void print_usage (ApplicationCommandLine command_line) {
command_line.print ("Usage: tuf-cli COMMAND [SUBCOMMAND] ...\n\n");
command_line.print (" version Print the version of tuf-cli\n");
command_line.print (" help Show this help screen\n");
command_line.print (" fan [balanced, turbo, silent] Set the fan mode\n");
command_line.print (" lighting [static, breath, cycle, stobe] Set the keyboard lighting\n");
command_line.print (" speed [slow, medium, fast] Set the keyboard lighting speed\n");
command_line.print (" color [#XXXXXX] Set the keyboadd color\n");
command_line.print (" info Show the current config\n\n");
command_line.print ("Examples:\n");
command_line.print (" Silence fan: tuf-cli fan silent\n");
command_line.print (" Change RGB color: tuf-cli color #FF0000\n");
}
/**
* This method releases the command line program from it's loop
*/
public void release_cli () {
#if ALWAYS_AUTHENTICATED
#else
if (pkttyagent != null) {
pkttyagent.force_exit ();
}
#endif
this.release ();
}
public override int command_line (ApplicationCommandLine command_line) {
// keep the application running until we are done with this commandline
this.hold ();
int res = _command_line (command_line);
return res;
}
}
}
}

148
src/common.vala Normal file
View File

@@ -0,0 +1,148 @@
/*
* Copyright 2020 Chris Cromer
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/**
* The TUF Manager namespace
*/
namespace TUFManager {
private TUFServerInterface tuf_server;
private BusName bus_name;
private void connect_dbus () throws TUFError {
bus_name = new BusName ("org.tuf.manager");
connect_tuf_server ();
if (get_server_version () != VERSION) {
throw new TUFError.UNMATCHED_VERSIONS ("The server and client versions do not match!");
}
}
private void connect_tuf_server () {
try {
tuf_server = Bus.get_proxy_sync (BusType.SYSTEM, "org.tuf.manager.server", "/org/tuf/manager/server");
}
catch (IOError e) {
stderr.printf ("Error: %s\n", e.message);
}
}
private string? get_server_version () {
try {
return tuf_server.get_server_version ();
}
catch (Error e) {
stderr.printf ("Error: %s\n", e.message);
}
return null;
}
private int get_fan_mode () {
try {
return tuf_server.get_fan_mode ();
}
catch (TUFError e) {
stderr.printf ("Error: %s\n", e.message);
}
catch (Error e) {
stderr.printf ("Error: %s\n", e.message);
}
return -3;
}
private void set_fan_mode (int mode) {
try {
tuf_server.set_fan_mode (mode, bus_name);
}
catch (TUFError e) {
stderr.printf ("Error: %s\n", e.message);
}
catch (Error e) {
stderr.printf ("Error: %s\n", e.message);
}
}
private Gdk.RGBA get_keyboard_color () {
try {
return tuf_server.get_keyboard_color ();
}
catch (TUFError e) {
stderr.printf ("Error: %s\n", e.message);
}
catch (Error e) {
stderr.printf ("Error: %s\n", e.message);
}
return Gdk.RGBA ();
}
private void set_keyboard_color (Gdk.RGBA color) {
try {
tuf_server.set_keyboard_color (color, bus_name);
}
catch (TUFError e) {
stderr.printf ("Error: %s\n", e.message);
}
catch (Error e) {
stderr.printf ("Error: %s\n", e.message);
}
}
private int get_keyboard_mode () {
try {
return tuf_server.get_keyboard_mode ();
}
catch (TUFError e) {
stderr.printf ("Error: %s\n", e.message);
}
catch (Error e) {
stderr.printf ("Error: %s\n", e.message);
}
return -3;
}
private void set_keyboard_mode (int mode) {
try {
tuf_server.set_keyboard_mode (mode, bus_name);
}
catch (TUFError e) {
stderr.printf ("Error: %s\n", e.message);
}
catch (Error e) {
stderr.printf ("Error: %s\n", e.message);
}
}
private int get_keyboard_speed () {
try {
return tuf_server.get_keyboard_speed ();
}
catch (TUFError e) {
stderr.printf ("Error: %s\n", e.message);
}
catch (Error e) {
stderr.printf ("Error: %s\n", e.message);
}
return -3;
}
private void set_keyboard_speed (int speed) {
try {
tuf_server.set_keyboard_speed (speed, bus_name);
}
catch (TUFError e) {
stderr.printf ("Error: %s\n", e.message);
}
catch (Error e) {
stderr.printf ("Error: %s\n", e.message);
}
}
}

38
src/config.vala.in Normal file
View File

@@ -0,0 +1,38 @@
/*
* Copyright 2020 Chris Cromer
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/**
* The TUF Manager namespace
*/
namespace TUFManager {
/**
* The package name used for translations
*/
public const string GETTEXT_PACKAGE = "@GETTEXT_PACKAGE@";
/**
* The version of the application
*/
public const string VERSION = "@VERSION@";
/**
* The location of the thermal control
*/
public const string THERMAL_PATH = "/sys/devices/platform/faustus/throttle_thermal_policy";
public const string RED_PATH = "/sys/devices/platform/faustus/kbbl/kbbl_red";
public const string GREEN_PATH = "/sys/devices/platform/faustus/kbbl/kbbl_green";
public const string BLUE_PATH = "/sys/devices/platform/faustus/kbbl/kbbl_blue";
public const string KEYBOARD_MODE_PATH = "/sys/devices/platform/faustus/kbbl/kbbl_mode";
public const string KEYBOARD_FLAGS_PATH = "/sys/devices/platform/faustus/kbbl/kbbl_flags";
public const string KEYBOARD_SPEED_PATH = "/sys/devices/platform/faustus/kbbl/kbbl_speed";
public const string KEYBOARD_SET_PATH = "/sys/devices/platform/faustus/kbbl/kbbl_set";
}

41
src/error.vala Normal file
View File

@@ -0,0 +1,41 @@
/*
* Copyright 2020 Chris Cromer
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/**
* The TUF Manager namespace
*/
namespace TUFManager {
/**
* This contains errors related to TUF Manager
*/
public errordomain TUFError {
/**
* The stream failed to open
*/
STREAM,
/**
* An invalid value was returned
*/
INVALID_VALUE,
/**
* The server is busy and can't do another task yet
*/
BUSY,
/**
* The client and serer version don't match
*/
UNMATCHED_VERSIONS,
UNAUTHORIZED
}
}

247
src/gui-window.vala Normal file
View File

@@ -0,0 +1,247 @@
/*
* Copyright 2020 Chris Cromer
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/**
* The TUF Manager namespace
*/
namespace TUFManager {
/**
* The GUI namespace contains a GTK based interface to interact with the TUF laptop
*/
namespace GUI {
/**
* The main window to show to the user
*/
[GtkTemplate (ui = "/cl/cromer/tuf-manager/tuf.manager.window.ui")]
public class MainWindow : Gtk.ApplicationWindow {
/**
* This is used to make sure that the sysfs files are not written to until everything is initialized
*/
private bool initialized = false;
private Settings settings;
/**
* The fan mode combo box
*/
[GtkChild]
private Gtk.ComboBoxText fan_mode;
[GtkChild]
private Gtk.ComboBoxText keyboard_mode;
[GtkChild]
private Gtk.ComboBoxText keyboard_speed;
/**
* The color chooser widget
*/
[GtkChild]
private Gtk.ColorChooserWidget keyboard_color;
/**
* Create the main window
* @param application The application used to make the GLib object
*/
public MainWindow (Gtk.Application application) {
Object (application: application);
}
public void initialize () {
settings = new Settings ("org.tuf.manager");
try {
connect_dbus ();
}
catch (TUFError e) {
stderr.printf ("Error: %s:\n", e.message);
if (e.code == TUFError.UNMATCHED_VERSIONS) {
Gtk.MessageDialog msg;
msg = new Gtk.MessageDialog (this,
Gtk.DialogFlags.MODAL,
Gtk.MessageType.ERROR,
Gtk.ButtonsType.CLOSE,
_ ("The current running tuf-server version doesn't match the gui version!"));
msg.response.connect ((response_id) => {
msg.destroy ();
this.close ();
});
msg.show ();
}
}
finally {
print (_ ("Client version: ") + VERSION + "\n");
print (_ ("Server version: ") + get_server_version () + "\n");
if (settings.get_boolean ("restore")) {
restore ();
}
else {
// Get the fan speed
// 0 - normal
// 1 - boost
// 2 - silent
var mode = get_fan_mode ();
if (mode >= 0) {
fan_mode.set_active (mode);
print (_ ("Current fan mode: ") + fan_mode.get_active_text () + "\n");
}
else {
stderr.printf ("%s\n", _ ("Error: Could not get current fan mode!"));
}
// Get the keyboard mode
mode = get_keyboard_mode ();
if (mode >= 0) {
keyboard_mode.set_active (mode);
if (mode == 2) {
keyboard_color.sensitive = false;
}
if (mode == 0 || mode == 3) {
keyboard_speed.sensitive = false;
}
print (_ ("Current keyboard mode: ") + keyboard_mode.get_active_text () + "\n");
}
else {
stderr.printf ("%s\n", _ ("Error: Could not get current keyboard mode!"));
}
// Get the keyboard speed
var speed = get_keyboard_speed ();
if (speed >= 0) {
keyboard_speed.set_active (mode);
print (_ ("Current keyboard speed: ") + keyboard_speed.get_active_text () + "\n");
}
else {
stderr.printf ("%s\n", _ ("Error: Could not get current keyboard speed!"));
}
// Get the keyboard color
var color = get_keyboard_color ();
keyboard_color.set_rgba (color);
print (_ ("Current keyboard color: ") + color.to_string () + "\n");
}
initialized = true;
}
}
public void restore () {
var mode = settings.get_int ("fan-mode");
if (mode >= 0 && mode <= 2) {
if (get_fan_mode () != mode) {
set_fan_mode (mode);
}
fan_mode.set_active (mode);
}
print (_ ("Current fan mode: ") + fan_mode.get_active_text () + "\n");
mode = settings.get_int ("keyboard-mode");
if (mode >= 0 && mode <= 3) {
if (get_keyboard_mode () != mode) {
set_keyboard_mode (mode);
}
keyboard_mode.set_active (mode);
if (mode == 2) {
keyboard_color.sensitive = false;
}
if (mode == 0 || mode == 3) {
keyboard_speed.sensitive = false;
}
}
print (_ ("Current keyboard mode: ") + keyboard_mode.get_active_text () + "\n");
var speed = settings.get_int ("keyboard-speed");
if (speed >= 0 && speed <= 2) {
if (get_keyboard_speed () != speed) {
set_keyboard_speed (speed);
}
keyboard_speed.set_active (speed);
}
print (_ ("Current keyboard speed: ") + keyboard_speed.get_active_text () + "\n");
var color = settings.get_string ("keyboard-color");
var rgba = Gdk.RGBA ();
rgba.parse (color);
if (!get_keyboard_color ().equal (rgba)) {
set_keyboard_color (rgba);
}
keyboard_color.set_rgba (rgba);
print (_ ("Current keyboard color: ") + color.to_string () + "\n");
}
/**
* Called when the user changes the fan mode
*
* * 1 - normal mode
* * 2 - boost mode
* * 3 - silent mode
* @param combo_box The combo box that changed
*/
[GtkCallback]
public void on_fan_mode_changed (Gtk.ComboBox combo_box) {
if (initialized) {
int mode = combo_box.get_active ();
set_fan_mode (mode);
settings.set_int ("fan-mode", mode);
}
}
/**
* Called when the user changes the keyboard lighting mode
* @param combo_box The combo box that changed
*/
[GtkCallback]
public void on_keyboard_mode_changed (Gtk.ComboBox combo_box) {
if (initialized) {
int mode = combo_box.get_active ();
if (mode == 2) {
keyboard_color.sensitive = false;
}
else {
keyboard_color.sensitive = true;
}
if (mode == 1 || mode == 2) {
keyboard_speed.sensitive = true;
}
else {
keyboard_speed.sensitive = false;
}
set_keyboard_mode (mode);
settings.set_int ("keyboard-mode", mode);
}
}
[GtkCallback]
public void on_speed_changed (Gtk.ComboBox combo_box) {
if (initialized) {
int speed = combo_box.get_active ();
set_keyboard_speed (speed);
settings.set_int ("keyboard-speed", speed);
}
}
[GtkCallback]
public void on_set_color_clicked (Gtk.Button button) {
if (initialized) {
Gdk.RGBA rgba = keyboard_color.get_rgba ();
set_keyboard_color (rgba);
settings.set_string ("keyboard-color", rgba.to_string ());
}
}
}
}
}

60
src/gui.vala Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright 2020 Chris Cromer
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/**
* The TUF Manager namespace
*/
namespace TUFManager {
/**
* The GUI namespace contains a GTK based interface to interact with the TUF laptop
*/
namespace GUI {
/**
* The application class
*/
public class TUFManagerApp : Gtk.Application {
/**
* The main application window
*/
private MainWindow window;
/**
* Initialize the application and set it's id
*/
public TUFManagerApp () {
application_id = "cl.cromer.tuf.manager";
}
/**
* Run when the application is activated
*/
public override void activate () {
window = new MainWindow (this);
window.icon = new Gtk.Image.from_resource ("/cl/cromer/tuf-manager/pixdata/tuf-manager.png").get_pixbuf ();
window.show_all ();
window.initialize ();
}
/**
* Run when the application starts
*/
public override void startup () {
Intl.textdomain (GETTEXT_PACKAGE);
Intl.setlocale (LocaleCategory.ALL, "");
base.startup ();
}
}
}
}

39
src/main.vala.in Normal file
View File

@@ -0,0 +1,39 @@
/*
* Copyright 2020 Chris Cromer
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/**
* The TUF Manager namespace
*/
namespace TUFManager {
/**
* The entry point to the TUF Manager application
*
* @param args Arguments passed from the command line
* @return Returns the status from the application
*/
public static int main (string[] args) {
var application = new @APP@.TUFManagerApp ();
try {
application.register ();
}
catch (Error e) {
stderr.printf ("Error: %s\n", e.message);
}
if (application.get_is_remote ()) {
stderr.printf ("Error: %s\n", _ ("Another instance of TUF Manager is already running!"));
return -1;
}
return application.run (args);
}
}

154
src/meson.build Normal file
View File

@@ -0,0 +1,154 @@
server_dependencies = [
dependency('glib-2.0'),
dependency('gtk+-3.0', version: '>=3.0.0'),
meson.get_compiler('c').find_library('m', required: true)
]
# if not always authenticated then polkit will be used for authentication
if not always_authenticated
server_dependencies += [dependency('polkit-gobject-1')]
endif
if build_cli
cli_dependencies = [
dependency('glib-2.0'),
dependency('gtk+-3.0', version: '>=3.0.0')
]
endif
if build_gui
gui_dependencies = [
dependency('glib-2.0'),
dependency('gobject-2.0'),
dependency('gtk+-3.0', version: '>=3.10.0'),
dependency('gmodule-2.0', version: '>=2.0') # gmodule-export-2.0 is needed to connect the handlers from glade ui
]
endif
config_data = configuration_data()
config_data.set('VERSION', meson.project_version())
config_data.set('GETTEXT_PACKAGE', meson.project_name())
config_data_file = configure_file(
input: 'config.vala.in',
output: 'config.vala',
configuration: config_data
)
if build_cli
config_data = configuration_data()
config_data.set('APP', 'CLI')
cli_main_file = configure_file(
input: 'main.vala.in',
output: 'cli-main.vala',
configuration: config_data
)
endif
if build_gui
config_data = configuration_data()
config_data.set('APP', 'GUI')
gui_main_file = configure_file(
input: 'main.vala.in',
output: 'gui-main.vala',
configuration: config_data
)
endif
error_vala_sources = files(
'error.vala'
)
# The sources containing a main function definition are separated to prevent
# conflict errors when building valadoc. valadoc doesn't like multiple entry
# points even if they are in different namespaces.
server_vala_sources_main = files(
'server-main.vala'
)
server_vala_sources = files(
'server.vala',
'server-interface.vala'
)
if build_cli
cli_vala_sources = files(
'cli.vala',
'server-interface.vala',
'common.vala'
)
endif
if build_gui
gui_vala_sources = files(
'gui.vala',
'gui-window.vala',
'server-interface.vala',
'common.vala'
)
endif
server_sources = server_vala_sources
server_sources += server_vala_sources_main
server_sources += error_vala_sources
server_sources += config_data_file
if build_cli
cli_sources = cli_vala_sources
cli_sources += cli_main_file
cli_sources += error_vala_sources
cli_sources += config_data_file
endif
if build_gui
gui_sources = gui_vala_sources
gui_sources += gui_main_file
gui_sources += error_vala_sources
gui_sources += [tuf_manager_gresource]
gui_sources += config_data_file
endif
server_vala_args = []
if always_authenticated
server_vala_args += ['--define=ALWAYS_AUTHENTICATED']
endif
if build_cli
cli_vala_args = []
if always_authenticated
cli_vala_args += ['--define=ALWAYS_AUTHENTICATED']
endif
endif
if build_gui
gui_vala_args = ['--gresources='+join_paths(meson.source_root(), 'data/ui/tuf.manager.gresource.xml')]
endif
server_exe = executable(
'tuf-server',
server_sources,
dependencies: server_dependencies,
vala_args: server_vala_args,
install: true,
install_dir: join_paths(get_option('libexecdir'), meson.project_name())
)
if build_cli
cli_exe = executable(
'tuf-cli',
cli_sources,
vala_args: cli_vala_args,
dependencies: cli_dependencies,
install: true
)
endif
if build_gui
gui_exe = executable(
'tuf-gui',
gui_sources,
dependencies: gui_dependencies,
vala_args: gui_vala_args,
install: true
)
endif

35
src/server-interface.vala Normal file
View File

@@ -0,0 +1,35 @@
/*
* Copyright 2020 Chris Cromer
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/**
* The TUF Manager namespace
*/
namespace TUFManager {
/**
* This interface defines the dbus daemon provided by the server
*/
[DBus (name = "org.tuf.manager.server")]
public interface TUFServerInterface : Object {
public abstract string get_server_version () throws Error;
public abstract int get_fan_mode () throws Error, TUFError;
public abstract void set_fan_mode (int mode, BusName sender) throws Error, TUFError;
public abstract Gdk.RGBA get_keyboard_color () throws Error, TUFError;
public abstract void set_keyboard_color (Gdk.RGBA color, BusName sender) throws Error, TUFError;
public abstract int get_keyboard_mode () throws Error, TUFError;
public abstract void set_keyboard_mode (int mode, BusName sender) throws Error, TUFError;
public abstract int get_keyboard_speed () throws Error, TUFError;
public abstract void set_keyboard_speed (int speed, BusName sender) throws Error, TUFError;
public signal void procedure_finished ();
}
}

44
src/server-main.vala Normal file
View File

@@ -0,0 +1,44 @@
/*
* Copyright 2020 Chris Cromer
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/**
* The TUF Manager namespace
*/
namespace TUFManager {
/**
* The server namespace contains anything releated to working as a dbus daemon
* and handling root related tasks
*/
namespace Server {
/**
* The entry point to the server launches a system dbus daemon
*
* @param args Arguments passed from the command line
* @return Returns 0 on success
*/
public static int main (string[] args) {
Bus.own_name (BusType.SYSTEM,
"org.tuf.manager.server",
BusNameOwnerFlags.NONE,
on_bus_acquired,
() => {},
() => {
stderr.printf ("Could not acquire name\n");
});
loop = new MainLoop ();
loop.run ();
return 0;
}
}
}

517
src/server.vala Normal file
View File

@@ -0,0 +1,517 @@
/*
* Copyright 2020 Chris Cromer
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/**
* The TUF Manager namespace
*/
namespace TUFManager {
/**
* The server namespace contains anything releated to working as a dbus daemon
* and handling root related tasks
*/
namespace Server {
/**
* The global instance of the server running as a dbus daemon
*/
TUFServer tuf_server;
/**
* The loop of the dbus daemon running in the background
*/
MainLoop loop;
/**
* Register the bus after the name has been aquired
*
* @param conn The connection to register with
*/
private void on_bus_acquired (DBusConnection conn) {
try {
tuf_server = new TUFManager.Server.TUFServer ();
}
catch (Error e) {
stderr.printf ("Error: %s\n", e.message);
}
try {
conn.register_object ("/org/tuf/manager/server", tuf_server);
}
catch (IOError e) {
stderr.printf ("Could not register service\n");
loop.quit ();
}
}
/**
* The TUF Server is a dbus service that runs in the background and uses
* root priveleges via polkit to make system changes
*/
[DBus (name = "org.tuf.manager.server")]
public class TUFServer : Object {
private Mutex locked;
private Mutex authorization;
private GenericSet<string> authorized_senders;
private MainContext context;
public signal void procedure_finished ();
/**
* The server class initialization
*
* @throws Error Thrown if there is a problem connecting to a dbus session or an IO error
*/
public TUFServer () throws Error {
locked = Mutex ();
authorization = Mutex ();
authorized_senders = new GenericSet<string> (str_hash, str_equal);
context = MainContext.ref_thread_default ();
}
/**
* Get authorization to run root tasks via polkit
*
* @param sender The bus that sent the request
* @throws Error Thrown if there is a problem connecting to a dbus session or an IO error
*/
private async bool get_authorization (BusName sender) throws Error {
#if ALWAYS_AUTHENTICATED
return true;
#else
bool authorized = false;
authorization.lock ();
bool fast_authorized = authorized_senders.contains (sender);
authorization.unlock ();
if (fast_authorized) {
var idle = new IdleSource ();
idle.set_priority (Priority.DEFAULT);
idle.set_callback (() => {
return false;
});
idle.attach (context);
return true;
}
try {
Polkit.Authority authority = yield Polkit.Authority.get_async ();
Polkit.Subject subject = new Polkit.SystemBusName (sender);
var result = yield authority.check_authorization (
subject,
"org.tuf.manager.save",
null,
Polkit.CheckAuthorizationFlags.ALLOW_USER_INTERACTION);
authorized = result.get_is_authorized ();
}
catch (Error e) {
stderr.printf ("Error: %s\n", e.message);
}
/*if (!authorized) {
stderr.printf ("%s\n", _ ("Authentication failed!"));
}
else {
stderr.printf ("%s\n", _ ("Authentication passed!"));
}*/
return authorized;
#endif
}
/**
* Get the version of the currently running server
*
* @return Returns a string containing the version
* @throws Error Thrown if there is a problem connecting to a dbus session or an IO error
*/
public string get_server_version () throws Error {
return VERSION;
}
/**
* Get the current fan mode
*
* @return Returns the current fan mode
* @throws Error Thrown if there is a problem connecting to a dbus session or an IO error
* @throws TUFError Thrown if there is a problem reading a value from the stream
*/
public int get_fan_mode () throws Error, TUFError {
var stream = FileStream.open (THERMAL_PATH, "r");
if (stream == null) {
throw new TUFError.STREAM (_ ("Failed to open stream!"));
}
var line = stream.read_line ();
if (line == null) {
throw new TUFError.INVALID_VALUE (_ ("File is empty!"));
}
var mode = int.parse (line);
if (mode < 0 || mode > 2) {
throw new TUFError.INVALID_VALUE (_ ("File contains invalid value!"));
}
return mode;
}
/**
* Set a new fan mode
*
* * 1 - normal mode
* * 2 - boost mode
* * 3 - silent mode
*
* @param mode The new mode to set
* @throws Error Thrown if there is a problem connecting to a dbus session or an IO error
* @throws TUFError Thrown if there is a problem writing a value to the stream
*/
public void set_fan_mode (int mode, BusName sender) throws Error, TUFError {
get_authorization.begin (sender, (obj, res) => {
bool authorized = false;
try {
authorized = get_authorization.end (res);
}
catch (TUFError e) {
stderr.printf ("Error: %s\n", e.message);
}
catch (Error e) {
stderr.printf ("Error: %s\n", e.message);
}
if (authorized) {
try {
set_fan_mode_authorized (mode, sender);
}
catch (TUFError e) {
stderr.printf ("Error: %s\n", e.message);
}
catch (Error e) {
stderr.printf ("Error: %s\n", e.message);
}
}
else {
// Not authorized, so let's end this
procedure_finished ();
}
});
}
private void set_fan_mode_authorized (int mode, BusName sender) throws Error, TUFError {
locked.lock ();
var stream = FileStream.open (THERMAL_PATH, "w");
if (stream == null) {
locked.unlock ();
throw new TUFError.STREAM (_ ("Failed to open stream!"));
}
if (mode < 0 || mode > 2) {
locked.unlock ();
throw new TUFError.INVALID_VALUE (_ ("Invalid value!"));
}
stream.puts (mode.to_string ());
locked.unlock ();
procedure_finished ();
}
public Gdk.RGBA get_keyboard_color () throws Error, TUFError {
string color = "#";
// Get red
var stream = FileStream.open (RED_PATH, "r");
if (stream == null) {
throw new TUFError.STREAM (_ ("Failed to open stream!"));
}
var line = stream.read_line ();
if (line == null) {
throw new TUFError.INVALID_VALUE (_ ("File is empty!"));
}
color += line;
// Get green
stream = FileStream.open (GREEN_PATH, "r");
if (stream == null) {
throw new TUFError.STREAM (_ ("Failed to open stream!"));
}
line = stream.read_line ();
if (line == null) {
throw new TUFError.INVALID_VALUE (_ ("File is empty!"));
}
color += line;
// Get blue
stream = FileStream.open (BLUE_PATH, "r");
if (stream == null) {
throw new TUFError.STREAM (_ ("Failed to open stream!"));
}
line = stream.read_line ();
if (line == null) {
throw new TUFError.INVALID_VALUE (_ ("File is empty!"));
}
color += line;
var rgba = Gdk.RGBA ();
rgba.parse (color);
return rgba;
}
public void set_keyboard_color (Gdk.RGBA color, BusName sender) throws Error, TUFError {
get_authorization.begin (sender, (obj, res) => {
bool authorized = false;
try {
authorized = get_authorization.end (res);
}
catch (TUFError e) {
stderr.printf ("Error: %s\n", e.message);
}
catch (Error e) {
stderr.printf ("Error: %s\n", e.message);
}
if (authorized) {
try {
set_keyboard_color_authorized (color, sender);
}
catch (TUFError e) {
stderr.printf ("Error: %s\n", e.message);
}
catch (Error e) {
stderr.printf ("Error: %s\n", e.message);
}
}
else {
// Not authorized, so let's end this
procedure_finished ();
}
});
}
private void set_keyboard_color_authorized (Gdk.RGBA color, BusName sender) throws Error, TUFError {
locked.lock ();
var red = "%02x".printf ((uint) (Math.round (color.red * 255))).up ();
var green = "%02x".printf ((uint) (Math.round (color.green * 255))).up ();
var blue = "%02x".printf ((uint) (Math.round (color.blue * 255))).up ();
var keyboard_set = "1";
var keyboard_flags = "2a";
var stream = FileStream.open (RED_PATH, "w");
if (stream == null) {
locked.unlock ();
throw new TUFError.STREAM (_ ("Failed to open stream!"));
}
stream.puts (red);
stream = FileStream.open (GREEN_PATH, "w");
if (stream == null) {
locked.unlock ();
throw new TUFError.STREAM (_ ("Failed to open stream!"));
}
stream.puts (green);
stream = FileStream.open (BLUE_PATH, "w");
if (stream == null) {
locked.unlock ();
throw new TUFError.STREAM (_ ("Failed to open stream!"));
}
stream.puts (blue);
stream = FileStream.open (KEYBOARD_FLAGS_PATH, "w");
if (stream == null) {
locked.unlock ();
throw new TUFError.STREAM (_ ("Failed to open stream!"));
}
stream.puts (keyboard_flags);
stream = FileStream.open (KEYBOARD_SET_PATH, "w");
if (stream == null) {
locked.unlock ();
throw new TUFError.STREAM (_ ("Failed to open stream!"));
}
stream.puts (keyboard_set);
locked.unlock ();
}
public int get_keyboard_mode () throws Error, TUFError {
var stream = FileStream.open (KEYBOARD_MODE_PATH, "r");
if (stream == null) {
throw new TUFError.STREAM (_ ("Failed to open stream!"));
}
var line = stream.read_line ();
if (line == null) {
throw new TUFError.INVALID_VALUE (_ ("File is empty!"));
}
var mode = int.parse (line);
if (mode < 0 || mode > 3) {
throw new TUFError.INVALID_VALUE (_ ("File contains invalid value!"));
}
return mode;
}
public void set_keyboard_mode (int mode, BusName sender) throws Error, TUFError {
get_authorization.begin (sender, (obj, res) => {
bool authorized = false;
try {
authorized = get_authorization.end (res);
}
catch (TUFError e) {
stderr.printf ("Error: %s\n", e.message);
}
catch (Error e) {
stderr.printf ("Error: %s\n", e.message);
}
if (authorized) {
try {
set_keyboard_mode_authorized (mode, sender);
}
catch (TUFError e) {
stderr.printf ("Error: %s\n", e.message);
}
catch (Error e) {
stderr.printf ("Error: %s\n", e.message);
}
}
else {
// Not authorized, so let's end this
procedure_finished ();
}
});
}
private void set_keyboard_mode_authorized (int mode, BusName sender) throws Error, TUFError {
locked.lock ();
var keyboard_set = "1";
var keyboard_flags = "2a";
var stream = FileStream.open (KEYBOARD_MODE_PATH, "w");
if (stream == null) {
locked.unlock ();
throw new TUFError.STREAM (_ ("Failed to open stream!"));
}
if (mode < 0 || mode > 3) {
locked.unlock ();
throw new TUFError.INVALID_VALUE (_ ("Invalid value!"));
}
stream.puts (mode.to_string ());
stream = FileStream.open (KEYBOARD_FLAGS_PATH, "w");
if (stream == null) {
locked.unlock ();
throw new TUFError.STREAM (_ ("Failed to open stream!"));
}
stream.puts (keyboard_flags);
stream = FileStream.open (KEYBOARD_SET_PATH, "w");
if (stream == null) {
locked.unlock ();
throw new TUFError.STREAM (_ ("Failed to open stream!"));
}
stream.puts (keyboard_set);
locked.unlock ();
procedure_finished ();
}
public int get_keyboard_speed () throws Error, TUFError {
var stream = FileStream.open (KEYBOARD_SPEED_PATH, "r");
if (stream == null) {
throw new TUFError.STREAM (_ ("Failed to open stream!"));
}
var line = stream.read_line ();
if (line == null) {
throw new TUFError.INVALID_VALUE (_ ("File is empty!"));
}
var mode = int.parse (line);
if (mode < 0 || mode > 2) {
throw new TUFError.INVALID_VALUE (_ ("File contains invalid value!"));
}
return mode;
}
public void set_keyboard_speed (int speed, BusName sender) throws Error, TUFError {
get_authorization.begin (sender, (obj, res) => {
bool authorized = false;
try {
authorized = get_authorization.end (res);
}
catch (TUFError e) {
stderr.printf ("Error: %s\n", e.message);
}
catch (Error e) {
stderr.printf ("Error: %s\n", e.message);
}
if (authorized) {
try {
set_keyboard_speed_authorized (speed, sender);
}
catch (TUFError e) {
stderr.printf ("Error: %s\n", e.message);
}
catch (Error e) {
stderr.printf ("Error: %s\n", e.message);
}
}
else {
// Not authorized, so let's end this
procedure_finished ();
}
});
}
private void set_keyboard_speed_authorized (int speed, BusName sender) throws Error, TUFError {
locked.lock ();
var keyboard_set = "1";
var keyboard_flags = "2a";
var stream = FileStream.open (KEYBOARD_SPEED_PATH, "w");
if (stream == null) {
locked.unlock ();
throw new TUFError.STREAM (_ ("Failed to open stream!"));
}
if (speed < 0 || speed > 2) {
locked.unlock ();
throw new TUFError.INVALID_VALUE (_ ("Invalid value!"));
}
stream.puts (speed.to_string ());
stream = FileStream.open (KEYBOARD_FLAGS_PATH, "w");
if (stream == null) {
locked.unlock ();
throw new TUFError.STREAM (_ ("Failed to open stream!"));
}
stream.puts (keyboard_flags);
stream = FileStream.open (KEYBOARD_SET_PATH, "w");
if (stream == null) {
locked.unlock ();
throw new TUFError.STREAM (_ ("Failed to open stream!"));
}
stream.puts (keyboard_set);
locked.unlock ();
procedure_finished ();
}
}
}
}