rexy712/rexbacklight
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Compare commits

base: rexy712:master
Branches Tags
rexy712:master
rexy712:v1.5.2
rexy712:v1.5.1
rexy712:v1.5
rexy712:v1.4
rexy712:v1.3.1
rexy712:v1.3
rexy712:v1.2
rexy712:v1.1
rexy712:v1.0
..
compare: rexy712:v1.0
Branches Tags
rexy712:master
rexy712:v1.5.2
rexy712:v1.5.1
rexy712:v1.5
rexy712:v1.4
rexy712:v1.3.1
rexy712:v1.3
rexy712:v1.2
rexy712:v1.1
rexy712:v1.0

No commits in common. "master" and "v1.0" have entirely different histories.
master ... v1.0

21 changed files with 255 additions and 948 deletions
Show Stats Expand all files Collapse all files

2
.gitignore vendored
View File

@ -4,4 +4,4 @@ rexbacklight
rexledctl
*.swp
build
include/version.h
include/config.h

94
CMakeLists.txt
View File

@ -1,54 +1,17 @@
project(rexbacklight)
cmake_minimum_required(VERSION 3.1)
include(CMakeDependentOption)
include(GNUInstallDirs)
set(SCRIPT_DIR ${CMAKE_SOURCE_DIR}/scripts)
#set project include directory
cmake_minimum_required(VERSION 3.0.2)
project(rexbacklight)
set(rexbacklight_VERSION_MAJOR 1)
set(rexbacklight_VERSION_MINOR 0)
set(INCLUDE_PATH ${CMAKE_SOURCE_DIR}/include)
configure_file(
"${INCLUDE_PATH}/config.h.in"
"${INCLUDE_PATH}/config.h"
)
include_directories("${INCLUDE_PATH}")
set(GIT_VERSION_FILE ${CMAKE_SOURCE_DIR}/include/version.h)
set(GIT_VERSION_TMP_FILE ${CMAKE_SOURCE_DIR}/include/verison.h.tmp)
#require python on windows
#i know this program can't be built on windows, but i wanted to figure out how to do this
if(WIN32)
find_package(PythonInterp 3 REQUIRED)
else()
find_package(PythonInterp 3 QUIET)
endif()
if(PYTHONINTERP_FOUND)
add_custom_command(
OUTPUT ${GIT_VERSION_TMP_FILE}
COMMAND ${CMAKE_COMMAND} -E echo "//File generated by CMake. Do not edit!" > ${GIT_VERSION_TMP_FILE}
COMMAND ${CMAKE_COMMAND} -E echo "#define GIT_TAG_NAME \"v1.5.3\"" > ${GIT_VERSION_TMP_FILE}
COMMAND ${CMAKE_COMMAND} -E copy_if_different ${GIT_VERSION_TMP_FILE} ${GIT_VERSION_FILE}
COMMAND ${CMAKE_COMMAND} -E remove ${GIT_VERSION_TMP_FILE}
WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
COMMENT "Regenerating version.h"
VERBATIM
)
elseif(UNIX)
add_custom_command(
OUTPUT ${GIT_VERSION_TMP_FILE}
COMMAND ${CMAKE_COMMAND} -E echo "//File generated by CMake. Do not edit!" > ${GIT_VERSION_TMP_FILE}
COMMAND ${CMAKE_COMMAND} -E echo "#define GIT_TAG_NAME \"v1.5.3\"" > ${GIT_VERSION_TMP_FILE}
COMMAND ${CMAKE_COMMAND} -E copy_if_different ${GIT_VERSION_TMP_FILE} ${GIT_VERSION_FILE}
COMMAND ${CMAKE_COMMAND} -E remove ${GIT_VERSION_TMP_FILE}
WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
COMMENT "Regenerating version.h"
VERBATIM
)
endif()
#setup cmake options
option(BUILD_REXLEDCTL "Build led control program" ON)
option(BUILD_REXBACKLIGHT "Build backlight control program" ON)
option(ENABLE_RESTORE_FILE "Enable backlight restoration from generated save file" ON)
option(XBACKLIGHT_COMPAT "Use xbacklight style options (eg -get -inc -dec)" OFF)
CMAKE_DEPENDENT_OPTION(INSTALL_UDEV_LED_RULE "Install the udev rule to allow users of video group to control led devices" ON
"BUILD_REXLEDCTL" OFF)
CMAKE_DEPENDENT_OPTION(INSTALL_UDEV_BACKLIGHT_RULE "Install the udev rule to allow users of video group to control backlight devices" ON
@ -56,56 +19,21 @@ CMAKE_DEPENDENT_OPTION(INSTALL_UDEV_BACKLIGHT_RULE "Install the udev rule to all
set(UDEV_DIR "/etc/udev/rules.d" CACHE STRING "Set the output directory for udev rules")
mark_as_advanced(UDEV_DIR)
if(XBACKLIGHT_COMPAT)
add_definitions("-DXBACKLIGHT_COMPAT_OPTIONS")
endif()
#locate rjp library requirements
if(ENABLE_RESTORE_FILE)
find_package(PkgConfig REQUIRED)
pkg_check_modules(RJP REQUIRED rjp)
#temporary library (no actual library generated)
add_library(common_srcs OBJECT src/cmd.c src/common.c src/restore.c)
add_definitions("-DENABLE_RESTORE_FILE")
else()
add_library(common_srcs OBJECT src/cmd.c src/common.c)
endif()
target_sources(common_srcs PUBLIC ${GIT_VERSION_TMP_FILE})
set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -DREXBACKLIGHT_DEBUG")
#build led control program
if(BUILD_REXLEDCTL)
add_executable (rexledctl src/rexbacklight.c)
add_dependencies(rexledctl common_srcs) #force common_srcs to be built first
target_compile_definitions(rexledctl PRIVATE REXLEDCTL) #define REXLEDCTL in C files
target_link_libraries(rexledctl PRIVATE $<TARGET_OBJECTS:common_srcs>) #link with the common_srcs "library"
if(ENABLE_RESTORE_FILE)
target_link_libraries(rexledctl PRIVATE "${RJP_LIBRARIES}") #link with rjp
target_include_directories(rexledctl PUBLIC "${RJP_INCLUDE_DIRS}") #include rjp.h directory
target_compile_options(rexledctl PUBLIC ${RJP_CFLAGS_OTHER})
endif()
add_executable (rexledctl src/rexbacklight.c src/cmd.c src/common.c)
target_compile_definitions(rexledctl PRIVATE REXLEDCTL)
install(TARGETS rexledctl RUNTIME DESTINATION bin)
if(INSTALL_UDEV_LED_RULE)
install(FILES ${CMAKE_SOURCE_DIR}/rules/91-leds.rules DESTINATION ${UDEV_DIR})
endif()
endif()
#build backlight control program
if(BUILD_REXBACKLIGHT)
add_executable (rexbacklight src/rexbacklight.c)
add_dependencies(rexbacklight common_srcs)
add_executable (rexbacklight src/rexbacklight.c src/cmd.c src/common.c)
target_compile_definitions(rexbacklight PRIVATE REXBACKLIGHT)
target_link_libraries(rexbacklight PRIVATE $<TARGET_OBJECTS:common_srcs>)
if(ENABLE_RESTORE_FILE)
target_link_libraries(rexbacklight PRIVATE "${RJP_LIBRARIES}")
target_include_directories(rexbacklight PUBLIC "${RJP_INCLUDE_DIRS}")
target_compile_options(rexbacklight PUBLIC ${RJP_CFLAGS_OTHER})
endif()
install(TARGETS rexbacklight RUNTIME DESTINATION bin)
if(INSTALL_UDEV_BACKLIGHT_RULE)
install(FILES ${CMAKE_SOURCE_DIR}/rules/91-backlight.rules DESTINATION ${UDEV_DIR})
endif()
endif()
#uninstall target
add_custom_target(uninstall cat install_manifest.txt | xargs rm)

83
README.md
View File

@ -1,83 +0,0 @@
# README
## About
rexbacklight is a program designed to operate similarly to xbacklight. There is even a configure option to enable xbacklight arguments to make this a drop in replacement. However unlike xbacklight, this program does not use X11 to control the backlight devices. rexbacklight directly interacts with sysfs to change backlight levels, read their current status, and find their max output level. This has the advantage of allowing rexbacklight to run without the X server running and will work even if X doesn't recognize your backlight device, which was my original inspiration to make this project.
I've also since added a program to control LED devices, rexledctl (best name I could think of). This one was inspired by the fact that my laptop's keyboard backlight wasn't controllable by any program I had and the hardware button didn't work either. So now I have my own program which can control it. It was so similar in function to rexbacklight that I decided to just add some compile time `#define`'s and make a few things more modular in the code and have the same source files make 2 different programs.
Either program can be built alone or both together. This is configured using some cmake magic.
Current version is 1.5.2 as of writing this, so if the version is much newer, remind me to update this readme.
```
rexbacklight version v1.5.2
Usage: rexbacklight [argument] [options] [argument]
Options:
--device|-d
select which device to control
--fade|-f
change brightness over time interval
--steps|-s
number of steps over which to fade
--get|-g
print current brightness level to stdout
--list|-l
print device names to stdout and exit
--restore|-R
reassign previously saved device values
--no-save|-N
do not write any data to the restore file
--help|-h
print this help message and exit
--version
print program version and exit
Arguments:
=<percentage>
-<percentage>
+<percentage>
off
max
min
rexbacklight Copyright (C) 2018-2021 rexy712
This program comes with ABSOLUTELY NO WARRANTY.
This is free software, and you are welcome to redistribute it
under certain conditions; see the GNU GPLv3 for details.
A copy of the GPLv3 is available with the source in the file 'LICENSE'
```
## Dependencies
Requires the rjp ([rexy's json parser][rjp]) library for reading restore file, though this can be disabled via cmake configuration.
Either python3 or sh compatible shell to run some build scripts.
## Building
##### Run the following commands
```
mkdir build
cd build
ccmake ..
#or just 'cmake ..' and specify options on command line
make
```
## Installing
##### Run the following commands from the build directory after building
```
sudo make install
```
##### Reload the udev rules for them to take effect, otherwise just reboot
```
sudo udevadm control --reload-rules
sudo udevadm trigger
```
## Uninstalling
##### Run the following commands from the build directory
```
sudo make uninstall
```
[rjp]: https://gitlab.com/rexy712/rjp

2
TODO
View File

@ -1,7 +1,7 @@
#Individual device control
#List devices
#Query backlight percentage (get)
#xbacklight compat option (-get/-set/-inc/-dec/-help/-time/-steps)
xbacklight compat option (-get/-set/-inc/-dec/-help/-time/-steps)
#allow fade in and fade out
a lot of cleanup
#rename "backlight" things to "device" things because led/backlight ambiguity

23
include/cmd.h
View File

@ -1,6 +1,6 @@
/**
rexbacklight
Copyright (C) 2018-2021 rexy712
Copyright (C) 2018 rexy712
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
@ -16,28 +16,21 @@
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef REXBACKLIGHT_CMD_H
#ifndef RECBACKLIGHT_CMD_H
#define REXBACKLIGHT_CMD_H
#define OP_INC 1
#define OP_DEC 2
#define OP_SET 4
#define OP_LIST 8
#define OP_RESTORE 16
#define OP_GET 128
#define OP_NONE 0
#define OP_VERSION 254
#define OP_USAGE 255
#define ARG_FLAG_NONE 0
#define ARG_FLAG_NO_SAVE 1
struct cmd_arg{
const char* lopt;
const char* sopt;
#ifdef XBACKLIGHT_COMPAT_OPTIONS
const char* xopt;
#endif
const char* desc;
};
@ -51,11 +44,7 @@ struct arg_values{
//NULL means all devices
const char* device;
//starting brightness
int act_start;
//value to write in backlight file
int act_delta;
//output percentage
//What value to put in the backlight file
float delta;
//How many seconds to transition
@ -63,11 +52,7 @@ struct arg_values{
int fade_steps;
union{
int operation;
int num_values;
};
int flags;
unsigned char operation;
};

32
include/common.h
View File

@ -1,6 +1,6 @@
/**
rexbacklight
Copyright (C) 2018-2021 rexy712
Copyright (C) 2018 rexy712
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
@ -9,22 +9,18 @@
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
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, see <http://www.gnu.org/licenses/>.
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdlib.h>
#ifndef REXBACKLIGHT_COMMON_H
#define REXBACKLIGHT_COMMON_H
#ifdef REXBACKLIGHT_DEBUG
#define DEBUG_PRINT(s, ...) printf(s, __VA_ARGS__)
#else
#define DEBUG_PRINT(s, ...)
#endif
#define RETVAL_INVALID_FILE 1
#define RETVAL_INVALID_DIR 2
#define RETVAL_UNRECOGNIZED_OPTION 3
@ -33,27 +29,11 @@
#define RETVAL_MEM_ERROR 6
#define RETVAL_INTERNAL_ERROR 7
#define RETVAL_SUCCESS EXIT_SUCCESS
#define IO_ERROR_DIR "directory"
#define IO_ERROR_FILE "file"
#define IO_ERROR_OPEN "open"
#define IO_ERROR_READ "read"
#define IO_ERROR_WRITE "write to"
extern int return_value;
struct string_array{
char** list;
int size;
};
void free_string_array(struct string_array* s);
void io_error(const char* error, const char* type, const char* name);
void io_error_2(const char* error, const char* type, const char* name, const char* name2);
void io_error_3(const char* error, const char* type, const char* name, const char* name2, const char* name3);
void mem_error(void);
_Noreturn void version(void);
_Noreturn void usage(int exit_val);
#endif

35
include/config.h
View File

@ -1,35 +0,0 @@
/**
rexbacklight
Copyright (C) 2018-2021 rexy712
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 3 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, see <http://www.gnu.org/licenses/>.
*/
#ifndef CONFIG_H
#define CONFIG_H
#include "version.h"
#ifdef GIT_TAG_NAME
#ifdef GIT_DIRTY
#define REXBACKLIGHT_VERSION GIT_TAG_NAME "-dirty"
#else
#define REXBACKLIGHT_VERSION GIT_TAG_NAME
#endif
#else
#define REXBACKLIGHT_VERSION GIT_BRANCH_NAME "-" GIT_COMMIT_HASH
#endif
#endif

2
include/config.h.in Normal file
View File

@ -0,0 +1,2 @@
#define REXBACKLIGHT_VERSION_MAJOR 1
#define REXBACKLIGHT_VERSION_MINOR 0

28
include/globals.h
View File

@ -1,28 +0,0 @@
/**
rexbacklight
Copyright (C) 2018-2021 rexy712
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 3 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, see <http://www.gnu.org/licenses/>.
*/
#ifndef GLOBALS_H
#define GLOBALS_H
const char* device_dir(void);
const char* executable_name(void);
const char* restore_file_suffix(void);
const char* brightness_file(void);
const char* max_brightness_file(void);
#endif

33
include/restore.h
View File

@ -1,33 +0,0 @@
/**
rexbacklight
Copyright (C) 2018-2021 rexy712
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 3 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, see <http://www.gnu.org/licenses/>.
*/
#ifndef RESTORE_H
#define RESTORE_H
#include <rjp.h>
#include "common.h"
#include "cmd.h"
void save_restore_file(struct string_array* devices, struct arg_values* args);
int restore_to_delta(struct arg_values* curr);
void prep_restore(struct arg_values* a);
RJP_value* find_matching_json_device(const char* name, RJP_value* root);
RJP_value* read_restore_file(const char* file);
#endif

27
include/rexbacklight.h
View File

@ -1,27 +0,0 @@
/**
rexbacklight
Copyright (C) 2018-2021 rexy712
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 3 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, see <http://www.gnu.org/licenses/>.
*/
#ifndef REXBACKLIGHT_H
#define REXBACKLIGHT_H
#include "cmd.h"
float get_brightness(const char* file);
int individual_device_op(struct arg_values* curr);
#endif

8
scripts/git_branch_name.py
View File

@ -1,8 +0,0 @@
#!/usr/bin/python
import subprocess
output = subprocess.run(['git', 'rev-parse', "--abbrev-ref", "HEAD"], stdout=subprocess.PIPE).stdout.decode('utf-8').rstrip()
if output:
print("#define GIT_BRANCH_NAME " + '"' + output + '"')

7
scripts/git_branch_name.sh
View File

@ -1,7 +0,0 @@
#!/bin/sh
output="$(git rev-parse --abbrev-ref HEAD)"
if test -n "$output";then
echo "#define GIT_BRANCH_NAME \"$output\" //test"
fi

10
scripts/git_commit_hash.py
View File

@ -1,10 +0,0 @@
#!/usr/bin/python
import subprocess
output = subprocess.run(['git', 'describe', "--always", "--dirty", "--abbrev", "--match=\"NeVeRmAtCh\""], stdout=subprocess.PIPE).stdout.decode('utf-8').rstrip()
if output:
print("#define GIT_COMMIT_HASH " + '"' + output + '"')
if output.find("dirty") != -1:
print("#define GIT_DIRTY")

10
scripts/git_commit_hash.sh
View File

@ -1,10 +0,0 @@
#!/bin/sh
output="$(git describe --always --dirty --abbrev --match="NeVeRmAtCh")"
if test -n output;then
echo "#define GIT_COMMIT_HASH \"$output\""
if grep -q "dirty" <<< "$output";then
echo "#define GIT_DIRTY"
fi
fi

9
scripts/git_tag_name.py
View File

@ -1,9 +0,0 @@
#!/usr/bin/python
import subprocess
output = subprocess.run(['git', 'tag', "--points-at", "HEAD"], stdout=subprocess.PIPE).stdout.decode('utf-8').rstrip()
if output:
if output[0] == 'v' or output[0] == 'V':
print("#define GIT_TAG_NAME " + '"' + output[1:] + '"')

9
scripts/git_tag_name.sh
View File

@ -1,9 +0,0 @@
#!/bin/sh
output="$(git tag --points-at HEAD)"
if test -n "$output";then
if test "${output:0:1}" = "v" || test "${output:0:1}" = "V";then
echo "#define GIT_TAG_NAME \"${output:1}\""
fi
fi

174
src/cmd.c
View File

@ -1,6 +1,6 @@
/**
rexbacklight
Copyright (C) 2018-2021 rexy712
Copyright (C) 2018 rexy712
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
@ -16,104 +16,45 @@
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdio.h> //fprintf
#include <string.h> //strcmp
#include <stdlib.h> //malloc, free, strtol, atof
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "cmd.h"
#include "common.h"
#include "config.h"
#define NO_OPT NULL
#define GET_LONG_OPT "--get"
#define GET_SHORT_OPT "-g"
#define GET_XBACK_OPT "-get"
#define FADE_LONG_OPT "--fade"
#define FADE_SHORT_OPT "-f"
#define FADE_XBACK_OPT "-time"
#define STEPS_LONG_OPT "--steps"
#define STEPS_SHORT_OPT "-s"
#define STEPS_XBACK_OPT "-steps"
#define DEVICE_LONG_OPT "--device"
#define DEVICE_SHORT_OPT "-d"
#define DEVICE_XBACK_OPT "-display"
#define LIST_LONG_OPT "--list"
#define LIST_SHORT_OPT "-l"
#define LIST_XBACK_OPT NO_OPT
#define HELP_LONG_OPT "--help"
#define HELP_SHORT_OPT "-h"
#define HELP_XBACK_OPT "-help"
#define VERSION_LONG_OPT "--version"
#define VERSION_SHORT_OPT NO_OPT
#define VERSION_XBACK_OPT "-version"
#define SET_LONG_OPT NO_OPT
#define SET_SHORT_OPT NO_OPT
#define SET_XBACK_OPT "-set"
#define INC_LONG_OPT NO_OPT
#define INC_SHORT_OPT NO_OPT
#define INC_XBACK_OPT "-inc"
#define DEC_LONG_OPT NO_OPT
#define DEC_SHORT_OPT NO_OPT
#define DEC_XBACK_OPT "-dec"
#define RESTORE_LONG_OPT "--restore"
#define RESTORE_SHORT_OPT "-R"
#define RESTORE_XBACK_OPT NO_OPT
#define NO_SAVE_LONG_OPT "--no-save"
#define NO_SAVE_SHORT_OPT "-N"
#define NO_SAVE_XBACK_OPT NO_OPT
#define NO_OPT NULL
#define GET_LONG_OPT "--get"
#define GET_SHORT_OPT "-g"
#define FADE_LONG_OPT "--fade"
#define FADE_SHORT_OPT "-f"
#define STEPS_LONG_OPT "--steps"
#define STEPS_SHORT_OPT "-s"
#define DEVICE_LONG_OPT "--device"
#define DEVICE_SHORT_OPT "-d"
#define LIST_LONG_OPT "--list"
#define LIST_SHORT_OPT "-l"
#define HELP_LONG_OPT "--help"
#define HELP_SHORT_OPT "-h"
#define HELP_LONG_OPT "--help"
#define HELP_SHORT_OPT "-h"
#define VERSION_LONG_OPT "--version"
#define DEVICE_DESC "select which device to control"
#define FADE_DESC "change brightness over time interval"
#define STEPS_DESC "number of steps over which to fade"
#define GET_DESC "print current brightness level to stdout"
#define LIST_DESC "print device names to stdout and exit"
#define HELP_DESC "print this help message and exit"
#define VERSION_DESC "print program version and exit"
#define SET_DESC "set backlight device to specified value"
#define INC_DESC "increase backlight device by specified value"
#define DEC_DESC "decrease backlight device by specified value"
#define RESTORE_DESC "reassign previously saved device values"
#define NO_SAVE_DESC "do not write any data to the restore file"
static inline int strcmp_handle_null(const char* one, const char* two){
if(!one)
return 1;
if(!two)
return -1;
return strcmp(one, two);
}
#define CHECK_SHORT_OPTION(opt, arg) (!strcmp_handle_null(opt##_SHORT_OPT, arg))
#define CHECK_LONG_OPTION(opt, arg) (!strcmp_handle_null(opt##_LONG_OPT, arg))
#define CHECK_XBACK_OPTION(opt, arg) (!strcmp_handle_null(opt##_XBACK_OPT, arg))
#ifdef XBACKLIGHT_COMPAT_OPTIONS
#define OPTION(x) {x##_LONG_OPT, x##_SHORT_OPT, x##_XBACK_OPT, x##_DESC}
#define CHECK_OPTION(opt, arg) (CHECK_LONG_OPTION(opt, arg) || CHECK_SHORT_OPTION(opt, arg) || CHECK_XBACK_OPTION(opt, arg))
#else //XBACKLIGHT_COMPAT_OPTIONS
#define OPTION(x) {x##_LONG_OPT, x##_SHORT_OPT, x##_DESC}
#define CHECK_OPTION(opt, arg) (CHECK_LONG_OPTION(opt, arg) || CHECK_SHORT_OPTION(opt, arg))
#endif //XBACKLIGHT_COMPAT_OPTIONS
#define CHECK_SHORT_OPTION(opt, arg) (!strcmp(opt##_SHORT_OPT, arg))
#define CHECK_LONG_OPTION(opt, arg) (!strcmp(opt##_LONG_OPT, arg))
#define CHECK_OPTION(opt, arg) (!strcmp(opt##_LONG_OPT, arg) || !strcmp(opt##_SHORT_OPT, arg))
struct cmd_arg rexbacklight_args[] = {
OPTION(DEVICE),
OPTION(SET),
OPTION(INC),
OPTION(DEC),
OPTION(FADE),
OPTION(STEPS),
OPTION(GET),
OPTION(LIST),
#ifdef ENABLE_RESTORE_FILE
OPTION(RESTORE),
OPTION(NO_SAVE),
#endif
OPTION(HELP),
OPTION(VERSION)
{DEVICE_LONG_OPT, DEVICE_SHORT_OPT, "select which device to control"},
{FADE_LONG_OPT, FADE_SHORT_OPT, "change brightness over time interval"},
{STEPS_LONG_OPT, STEPS_SHORT_OPT, "number of steps over which to fade"},
{GET_LONG_OPT, GET_SHORT_OPT, "print current brightness level to stdout"},
{LIST_LONG_OPT, LIST_SHORT_OPT, "print device names to stdout and exit"},
{HELP_LONG_OPT, HELP_SHORT_OPT, "print this help message and exit"},
{VERSION_LONG_OPT, NO_OPT, "print program version and exit"}
};
int rexbacklight_args_length = sizeof(rexbacklight_args) / sizeof(rexbacklight_args[0]);
\
//Clean up a cmd_arg struct
void free_cmd_args(struct arg_values* a){
if(!a->next)
@ -140,14 +81,13 @@ void free_cmd_args(struct arg_values* a){
}while(0);
struct arg_values init_arg_values(void){
return (struct arg_values){.next = NULL, .device = NULL, .delta = 0, .fade_duration = 0, .fade_steps = 20, .operation = 0, .flags = 0};
return (struct arg_values){.next = NULL, .device = NULL, .delta = 0, .fade_duration = 0, .fade_steps = 20, .operation = 0};
}
//Convert command line arguments to flags
struct arg_values process_cmd_args(int argc, char** argv){
struct arg_values ret = init_arg_values();
struct arg_values* curr = &ret;
int nvals = 0;
int i;
//Skip argv[0]
@ -155,7 +95,7 @@ struct arg_values process_cmd_args(int argc, char** argv){
//Check for switches
if(CHECK_OPTION(GET, argv[i])){
curr->operation = OP_GET;
curr->operation |= OP_GET;
continue;
}else if(CHECK_OPTION(FADE, argv[i])){
@ -182,30 +122,23 @@ struct arg_values process_cmd_args(int argc, char** argv){
*(curr->next) = init_arg_values();
curr = curr->next;
curr->device = argv[++i];
++nvals;
continue;
}
else if(CHECK_OPTION(LIST, argv[i])){
free_cmd_args(&ret);
ret.operation = OP_LIST;
ret.next = NULL;
return ret;
}
else if(CHECK_OPTION(HELP, argv[i])){
free_cmd_args(&ret);
return (struct arg_values){.operation = OP_USAGE};
}
else if(CHECK_OPTION(VERSION, argv[i])){
else if(CHECK_LONG_OPTION(VERSION, argv[i])){
free_cmd_args(&ret);
return (struct arg_values){.operation = OP_VERSION};
}
else if(CHECK_OPTION(LIST, argv[i])){
curr->operation = OP_LIST;
}
#ifdef ENABLE_RESTORE_FILE
else if(CHECK_OPTION(RESTORE, argv[i])){
curr->operation = OP_RESTORE;
}
else if(CHECK_OPTION(NO_SAVE, argv[i])){
curr->flags |= ARG_FLAG_NO_SAVE;
}
#endif
else if(!strcmp(argv[i], "max")){
curr->operation = OP_SET;
curr->delta = 100;
@ -218,25 +151,6 @@ struct arg_values process_cmd_args(int argc, char** argv){
curr->operation = OP_SET;
curr->delta = 0;
}
#ifdef XBACKLIGHT_COMPAT_OPTIONS
else if(CHECK_OPTION(SET, argv[i])){
CHECK_NEXT_ARG();
curr->operation = OP_SET;
curr->delta = atof(argv[++i]);
}
else if(CHECK_OPTION(INC, argv[i])){
CHECK_NEXT_ARG();
curr->operation = OP_INC;
curr->delta = atof(argv[++i]);
}
else if(CHECK_OPTION(DEC, argv[i])){
CHECK_NEXT_ARG();
curr->operation = OP_DEC;
curr->delta = atof(argv[++i]);
}
#endif //XBACKLIGHT_COMPAT_OPTIONS
else if(argv[i][0] == '='){
curr->operation = OP_SET;
@ -295,19 +209,14 @@ struct arg_values process_cmd_args(int argc, char** argv){
curr->operation = ret.operation;
if(!curr->delta)
curr->delta = ret.delta;
}
if(curr->flags == ARG_FLAG_NONE){
curr->flags = ret.flags;
}
}
}
if(ret.next)
ret.num_values = nvals;
return ret;
}
#undef CHECK_OPTION
#undef UNRECOGNIZED_OPTION
#undef OPTION
//Process an operation
int process_op(struct arg_values* arg, float min, float current, float max){
@ -342,4 +251,3 @@ int process_op(struct arg_values* arg, float min, float current, float max){
return current;
}

59
src/common.c
View File

@ -1,6 +1,6 @@
/**
rexbacklight
Copyright (C) 2018-2021 rexy712
Copyright (C) 2018 rexy712
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
@ -19,71 +19,32 @@
#include "config.h"
#include "common.h"
#include "cmd.h"
#include "globals.h"
#include <stdio.h> //printf
#include <stdlib.h> //exit
#include <stdio.h>
int return_value = RETVAL_SUCCESS;
void io_error(const char* error, const char* type, const char* name){
fprintf(stderr, "Unable to %s %s '%s'!\n", error, type, name);
}
void io_error_2(const char* error, const char* type, const char* name, const char* name2){
fprintf(stderr, "Unable to %s %s '%s%s'!\n", error, type, name, name2);
}
void io_error_3(const char* error, const char* type, const char* name, const char* name2, const char* name3){
fprintf(stderr, "Unable to %s %s '%s%s%s'!\n", error, type, name, name2, name3);
}
void mem_error(void){
fprintf(stderr, "Failed to allocate memory! Unable to continue!\n");
}
//Clean up a string array
void free_string_array(struct string_array* s){
int i;
for(i = 0;i < s->size;++i)
free(s->list[i]);
free(s->list);
}
//name of the program being run so that we print the correct name in the usage
extern const char* executable_name;
_Noreturn void version(void){
printf("%s version %s\n", executable_name(), REXBACKLIGHT_VERSION);
printf("%s version %d.%d\n", executable_name, REXBACKLIGHT_VERSION_MAJOR, REXBACKLIGHT_VERSION_MINOR);
exit(return_value);
}
_Noreturn void usage(int exit_val){
int i;
printf("%s version %s\n\n", executable_name(), REXBACKLIGHT_VERSION);
printf("Usage: %s [argument] [options] [argument]\n\n", executable_name());
printf("%s version %d.%d\n\n", executable_name, REXBACKLIGHT_VERSION_MAJOR, REXBACKLIGHT_VERSION_MINOR);
printf("Usage: %s [argument] [options] [argument]\n\n", executable_name);
printf("Options:\n");
for(i = 0;i < rexbacklight_args_length;++i){
int printed = 0;
if(rexbacklight_args[i].lopt){
printf("%s", rexbacklight_args[i].lopt);
printed = 1;
}
if(rexbacklight_args[i].sopt){
if(printed)
printf("|");
else
printed = 1;
printf("%s", rexbacklight_args[i].sopt);
}
#ifdef XBACKLIGHT_COMPAT_OPTIONS
if(rexbacklight_args[i].xopt){
if(printed)
printf("|");
else
printed = 1;
printf("%s", rexbacklight_args[i].xopt);
}
#endif //XBACKLIGHT_COMPAT_OPTIONS
if(printed){
printf("\n");
printf(" %s\n", rexbacklight_args[i].desc);
}
printf(" %s|%s\n", rexbacklight_args[i].lopt, rexbacklight_args[i].sopt);
printf(" %s\n", rexbacklight_args[i].desc);
}
printf("\n");
printf("Arguments:\n");
@ -94,7 +55,7 @@ _Noreturn void usage(int exit_val){
printf(" max\n");
printf(" min\n");
printf("\n%s Copyright (C) 2018-2021 rexy712\n", executable_name());
printf("\n%s Copyright (C) 2018 rexy712\n", executable_name);
printf("This program comes with ABSOLUTELY NO WARRANTY.\n");
printf("This is free software, and you are welcome to redistribute it\n");
printf("under certain conditions; see the GNU GPLv3 for details.\n");

173
src/restore.c
View File

@ -1,173 +0,0 @@
/**
rexbacklight
Copyright (C) 2018-2021 rexy712
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 3 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, see <http://www.gnu.org/licenses/>.
*/
#include <stdio.h> //printf
#include <string.h> //strcmp, strlen
#include <rjp.h>
#include <sys/types.h> //getpwnam
#include <pwd.h> //getpwnam
#include <unistd.h> //chdir
#include <stdlib.h> //malloc, free
#include "restore.h"
#include "common.h"
#include "cmd.h"
#include "globals.h"
#include "rexbacklight.h"
static char* get_home_folder(void){
char* user = getenv("SUDO_USER");
char* home = getenv("HOME");
if(!home || user){
if(!user){
return NULL;
}
struct passwd* pw_entry = getpwnam(user);
if(!pw_entry){
return NULL;
}
home = pw_entry->pw_dir;
}
return home;
}
static char* restore_file(void){
char* home_folder = get_home_folder();
if(!home_folder)
return NULL;
//"/.config/rexbacklight.json"
size_t home_folder_len = strlen(home_folder);
size_t conf_len = strlen(restore_file_suffix());
char* rest_file = malloc(home_folder_len + conf_len + 1);
strncpy(rest_file, home_folder, home_folder_len);
strncpy(rest_file+home_folder_len, restore_file_suffix(), conf_len);
rest_file[home_folder_len+conf_len] = 0;
return rest_file;
}
RJP_value* read_restore_file(const char* file){
size_t filesize;
char* file_contents;
int i;
FILE* fp = fopen(file, "r");
if(!fp){
return NULL;
}
fseek(fp, 0, SEEK_END);
filesize = ftell(fp);
fseek(fp, 0, SEEK_SET);
file_contents = malloc(filesize+1);
i = fread(file_contents, filesize, 1, fp);
fclose(fp);
file_contents[filesize] = 0;
RJP_value* root = rjp_parse(file_contents, RJP_PARSE_ALLOW_COMMENTS, NULL);
free(file_contents);
return root;
}
static RJP_value* restore_file_handle(void){
static RJP_value* rf = NULL;
if(!rf){
char* f = restore_file();
rf = read_restore_file(f);
free(f);
}
return rf;
}
RJP_value* find_matching_json_device(const char* name, RJP_value* root){
RJP_object_iterator it;
rjp_init_object_iterator(&it, root);
for(RJP_value* curr = rjp_object_iterator_current(&it);curr;curr = rjp_object_iterator_next(&it)){
if(!strcmp(rjp_member_key(curr)->value, name)){
return curr;
}
}
return NULL;
}
//convert a restoration operation to a set operation
int restore_to_delta(struct arg_values* curr){
RJP_value* root = restore_file_handle();
if(!root){
fprintf(stderr, "Could not restore! No restore file found!\n");
return 0;
}
RJP_value* match = find_matching_json_device(curr->device, root);
if(!match){
fprintf(stderr, "No matching device '%s' in restore file!\n", curr->device);
return 0;
}
curr->operation = OP_SET;
curr->delta = rjp_get_float(match);
return 1;
}
void prep_restore(struct arg_values* a){
for(struct arg_values* curr = a;curr;curr = curr->next){
restore_to_delta(curr);
}
}
void save_restore_file(struct string_array* devices, struct arg_values* args){
RJP_object_iterator it;
RJP_value* rf = restore_file_handle();
if(!rf)
rf = rjp_new_object();
rjp_init_object_iterator(&it, rf);
for(RJP_value* mem = rjp_object_iterator_current(&it);mem;mem = rjp_object_iterator_next(&it)){
for(struct arg_values* curr = args->next, *prev = args;curr;prev = curr, curr = curr->next){
if(curr->operation != OP_SET || curr->flags & ARG_FLAG_NO_SAVE){
prev->next = curr->next;
free(curr);
curr = prev;
continue;
}
if(!strcmp(rjp_member_key(mem)->value, curr->device)){
rjp_set_float(mem, curr->delta);
prev->next = curr->next;
free(curr);
break;
}
}
}
for(struct arg_values* curr = args->next;curr;curr = curr->next){
if(curr->operation == OP_SET){
RJP_value* newmem = rjp_new_member(rf, curr->device, 0);
rjp_set_float(newmem, curr->delta);
}
}
free_cmd_args(args);
char* tmp = rjp_to_json(rf, RJP_FORMAT_NONE);
char* rfil = restore_file();
FILE* restf = fopen(rfil, "w");
if(!restf){
io_error(IO_ERROR_OPEN, IO_ERROR_FILE, rfil);
}else{
fprintf(restf, "//File generated by %s\n%s\n", executable_name(), tmp);
fclose(restf);
}
free(rfil);
rjp_free(tmp);
rjp_free_value(rf);
}

383
src/rexbacklight.c
View File

@ -1,6 +1,6 @@
/**
rexbacklight
Copyright (C) 2018-2021 rexy712
Copyright (C) 2018 rexy712
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
@ -16,60 +16,64 @@
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdio.h> //fprintf
#include <stdlib.h> //malloc, free
#include <string.h> //strlen, strcpy
#include <unistd.h> //chdir
#include <sys/types.h> //opendir
#include <dirent.h> //opendir
#include <sys/time.h> //gettimeofday
#include <time.h> //nanosleep
//Needed for usleep to work
#define _DEFAULT_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <dirent.h>
#include <sys/time.h>
#include <time.h>
#include "common.h"
#include "cmd.h"
#include "globals.h"
#include "config.h"
#ifdef ENABLE_RESTORE_FILE
#include "restore.h"
#endif
/////////////////////////////////////////////////////////////////////////////////////////////
//name of the program being run so that we print the correct name in the usage
#ifdef REXBACKLIGHT
//This is where backlight devices can be found in sysfs
const char* device_dir(void){return "/sys/class/backlight/";}
//name of the program being run so that we print the correct name in the usage
const char* executable_name(void){return "rexbacklight";}
//location of the restore file in the home directory
const char* restore_file_suffix(void){return "/.config/rexbacklight.json";}
static const char* device_dir = "/sys/class/backlight/";
const char* executable_name = "rexbacklight";
#elif defined(REXLEDCTL)
//This is where led devices can be found in sysfs
const char* device_dir(void){return "/sys/class/leds/";}
const char* executable_name(void){return "rexledctl";}
const char* restore_file_suffix(void){return "/.config/rexledctl.json";}
static const char* device_dir = "/sys/class/leds";
const char* executable_name = "rexledctl";
#else
#error "UNDEFINED PROGRAM NAME!"
#endif
static const char* brightness_file = "brightness";
static const char* max_brightness_file = "max_brightness";
const char* brightness_file(void){return "brightness";}
const char* max_brightness_file(void){return "max_brightness";}
//Used to store a dynamic array of dynamic strings and number of strings
struct string_array{
char** list;
int size;
};
#define IO_ERROR_DIR "directory"
#define IO_ERROR_FILE "file"
#define IO_ERROR_OPEN "open"
#define IO_ERROR_READ "read"
#define IO_ERROR_WRITE "write to"
/////////////////////////////////////////////////////////////////////////////////////////////
void io_error(const char* error, const char* type, const char* name){
fprintf(stderr, "Unable to %s %s '%s'!\n", error, type, name);
}
void io_error_2(const char* error, const char* type, const char* name, const char* name2){
fprintf(stderr, "Unable to %s %s '%s/%s'!\n", error, type, name, name2);
}
void io_error_3(const char* error, const char* type, const char* name, const char* name2, const char* name3){
fprintf(stderr, "Unable to %s %s '%s/%s/%s'!\n", error, type, name, name2, name3);
}
//create a copy of a string and append a '/' character to the end
char* add_slash_to(const char* name, size_t namelen){
char* newname = malloc(namelen + 2);
memcpy(newname, name, namelen);
newname[namelen++] = '/';
newname[namelen] = 0;
return newname;
//Clean up a string array
void free_string_array(struct string_array* s){
int i;
for(i = 0;i < s->size;++i)
free(s->list[i]);
free(s->list);
}
//Get a list of led/backlight devices in sysfs
@ -79,9 +83,9 @@ struct string_array get_device_sources(void){
struct string_array arr = {0};
int list_size = 8;
fd = opendir(device_dir());
fd = opendir(device_dir);
if(!fd){
io_error(IO_ERROR_OPEN, IO_ERROR_DIR, device_dir());
io_error(IO_ERROR_OPEN, IO_ERROR_DIR, device_dir);
return_value = RETVAL_INVALID_DIR;
return arr;
}
@ -94,24 +98,23 @@ struct string_array get_device_sources(void){
return arr;
}
#define MEMORY_ERROR() do{mem_error();return_value = RETVAL_MEM_ERROR;free_string_array(&arr);closedir(fd);}while(0)
for(arr.size = 0;(dir = readdir(fd));){
int slen;
//ignore '.' and '..'
if(!strcmp(dir->d_name, ".") || !strcmp(dir->d_name, "..")){
if(!strncmp(dir->d_name, ".", 1) || !strncmp(dir->d_name, "..", 2)){
continue;
}
//Resize list if more than 8 led/backlight devices exist (not likely)
if(arr.size >= list_size){
int j;
char** tmp = malloc(sizeof(const char*) * (list_size += 8));
if(!tmp){
mem_error();
return_value = RETVAL_MEM_ERROR;
free_string_array(&arr);
closedir(fd);
MEMORY_ERROR();
return (struct string_array){0};
}
for(int j = 0;j < arr.size;++j){
for(j = 0;j < arr.size;++j){
tmp[j] = arr.list[j];
}
free(arr.list);
@ -121,17 +124,16 @@ struct string_array get_device_sources(void){
slen = strlen(dir->d_name);
arr.list[arr.size] = malloc(slen + 1);
if(!arr.list[arr.size]){
mem_error();
return_value = RETVAL_MEM_ERROR;
free_string_array(&arr);
closedir(fd);
MEMORY_ERROR();
return (struct string_array){0};
}
strncpy(arr.list[arr.size], dir->d_name, slen);
strcpy(arr.list[arr.size], dir->d_name);
arr.list[arr.size][slen] = 0;
++arr.size;
}
#undef MEMORY_ERROR
closedir(fd);
return arr;
}
@ -156,175 +158,150 @@ float get_brightness(const char* file){
return atof(buff);
}
//return milliseconds since last boot
double get_time(void){
struct timespec t;
clock_gettime(CLOCK_BOOTTIME, &t);
return ((t.tv_sec * 1000.0) + (t.tv_nsec * 0.0000001));
}
//sleep thread for milliseconds
void sleep_for(double time){
DEBUG_PRINT("sleeping for %lf milliseconds\n", time);
struct timespec ts;
ts.tv_sec = (long)(time*0.0001);
ts.tv_nsec = ((time) - ts.tv_sec*1000) * 1000*1000;
nanosleep(&ts, NULL);
}
void return_to_root_dir(void){
if(chdir(device_dir())){
io_error(IO_ERROR_OPEN, IO_ERROR_DIR, device_dir());
return_value = RETVAL_INVALID_DIR;
}
}
//update brightness incrementally over requested millisecond time interval
void fade_out(struct arg_values* arg){
void fade_out(const char* device_name, int iv, int fv, int ms_duration, int steps){
FILE* fd;
double start, end;
double tdelta = 0; //amount of time that has passed in ms
float value = arg->act_start; //current value to write to file
double step_delta = (double)arg->fade_duration / arg->fade_steps;
double step_inc = step_delta;
float brdelta = (float)(arg->act_delta - arg->act_start) / arg->fade_steps; //amount brightness needs to change per iteration
struct timeval start, end;
double tdelta = 0; //amount of time that has passed in ms
float value = iv; //current value to write to file
int step_delta = ms_duration / steps;
int step_inc = step_delta;
float brdelta = (float)(fv - iv) / steps; //amount brightness needs to change per iteration
while(arg->fade_duration > tdelta){
while(ms_duration > tdelta){
//write
start = get_time();
fd = fopen(brightness_file(), "w+");
gettimeofday(&start, NULL);
fd = fopen(brightness_file, "w+");
if(!fd){
char* devname = add_slash_to(arg->device, strlen(arg->device));
io_error_3(IO_ERROR_OPEN, IO_ERROR_FILE, device_dir(), devname, brightness_file());
io_error_3(IO_ERROR_OPEN, IO_ERROR_FILE, device_dir, device_name, brightness_file);
return_value = RETVAL_INVALID_FILE;
free(devname);
return_to_root_dir();
return;
}
fprintf(fd, "%d", (int)value);
fclose(fd);
end = get_time();
gettimeofday(&end, NULL);
//calc time delta
tdelta += end - start;
tdelta += (((end.tv_sec * 1000.0) + (end.tv_usec / 1000.0)) - ((start.tv_sec * 1000.0) + (start.tv_usec / 1000.0)));
//calc next value to write
value += brdelta;
//waste excess time until next step
if(step_delta > tdelta){
sleep_for(step_delta - tdelta);
struct timespec ts;
ts.tv_sec = (long)((step_delta - tdelta)/1000);
ts.tv_nsec = ((step_delta - tdelta) - ts.tv_sec*1000) * 1000*1000;
nanosleep(&ts, NULL);
tdelta = step_delta;
}
//calc end of next step
step_delta += step_inc;
}
fd = fopen(brightness_file(), "w+");
fd = fopen(brightness_file, "w+");
if(!fd){
char* devname = add_slash_to(arg->device, strlen(arg->device));
io_error_3(IO_ERROR_OPEN, IO_ERROR_FILE, device_dir(), devname, brightness_file());
io_error_3(IO_ERROR_OPEN, IO_ERROR_FILE, device_dir, device_name, brightness_file);
return_value = RETVAL_INVALID_FILE;
free(devname);
return_to_root_dir();
return;
}
fprintf(fd, "%d", arg->act_delta);
fprintf(fd, "%d", fv);
fclose(fd);
return_to_root_dir();
}
int prep_offset(struct arg_values* args){
if(chdir(args->device)){
io_error_2(IO_ERROR_OPEN, IO_ERROR_DIR, device_dir(), args->device);
return RETVAL_INVALID_DIR;
}
args->act_start = get_brightness(brightness_file());
float act_max = get_brightness(max_brightness_file());
args->act_delta = process_op(args, 0, args->act_start, act_max);
float start_pec = (args->act_start / act_max) * 100.0;
if(args->operation == OP_INC){
args->delta = start_pec + args->delta;
}else if(args->operation == OP_DEC){
args->delta = start_pec - args->delta;
}
if(args->delta > 100)
args->delta = 100;
else if(args->delta < 0)
args->delta = 0;
args->operation = OP_SET;
//chdir back in do_assignment
return 0;
//Write value to device files
void do_assignment(struct arg_values* arg, const char* device){
int start = get_brightness(brightness_file);
int out = process_op(arg, 0, start, get_brightness(max_brightness_file));
fade_out(device, start, out, arg->fade_duration, arg->fade_steps);
}
//Run get operation
int do_get(struct arg_values* args){
void do_get(const char* device){
float curr, max;
if(chdir(args->device)){
io_error_2(IO_ERROR_OPEN, IO_ERROR_DIR, device_dir(), args->device);
return RETVAL_INVALID_DIR;
}
curr = get_brightness(brightness_file());
max = get_brightness(max_brightness_file());
curr = get_brightness(brightness_file);
max = get_brightness(max_brightness_file);
if(return_value == RETVAL_INVALID_FILE && (!curr || !max)){
fprintf(stdout, "%s", args->device);
fprintf(stdout, "%s", device);
}else{
fprintf(stdout, "%-25s %.2f\n", args->device, curr / max * 100);
fprintf(stdout, "%-25s %.2f\n", device, get_brightness(brightness_file) / get_brightness(max_brightness_file) * 100);
}
if(chdir(device_dir())){
io_error(IO_ERROR_OPEN, IO_ERROR_DIR, device_dir());
return RETVAL_INVALID_DIR;
}
return return_value;
}
//Run list operation
void do_list(struct arg_values* args){
printf("%s\n", args->device);
}
//Run requested operation on a per device basis
int run_device_operations(struct arg_values* a){
int changes = 0;
for(a = a->next;a;a = a->next){
switch(a->operation){
case OP_LIST:
do_list(a);
break;
case OP_GET:
return_value = do_get(a);
break;
#ifdef ENABLE_RESTORE_FILE
case OP_RESTORE:
if(!restore_to_delta(a)){
continue;
}
#endif
//Run list operation
void do_list(struct string_array* names){
int i;
for(i = 0;i < names->size;++i)
fprintf(stdout, "%s\n", names->list[i]);
}
//If devices were specified, this function will run
void individual_device_loop(struct arg_values* a){
struct arg_values* curr;
for(curr = a->next;curr;curr = curr->next){
if(chdir(curr->device)){
io_error_2(IO_ERROR_OPEN, IO_ERROR_DIR, device_dir, curr->device);
return_value = RETVAL_INVALID_DIR;
continue;
}
switch(curr->operation){
case OP_SET:
case OP_INC:
case OP_DEC:
do_assignment(curr, curr->device);
break;
case OP_GET:
do_get(curr->device);
break;
}
if(chdir(device_dir)){
io_error(IO_ERROR_OPEN, IO_ERROR_DIR, device_dir);
return_value = RETVAL_INVALID_DIR;
return;
}
}
}
//If no devices were specified, this function will run
void all_device_loop(struct string_array* device_names, struct arg_values* args){
int i;
switch(args->operation){
case OP_SET:
case OP_INC:
case OP_DEC:
case OP_SET:
if(prep_offset(a))
break;
++changes;
fade_out(a);
for(i = 0;i < device_names->size;++i){
if(chdir(device_names->list[i])){
io_error_2(IO_ERROR_OPEN, IO_ERROR_DIR, device_dir, device_names->list[i]);
return_value = RETVAL_INVALID_DIR;
continue;
}
do_assignment(args, device_names->list[i]);
if(chdir(device_dir)){
io_error(IO_ERROR_OPEN, IO_ERROR_DIR, device_dir);
return_value = RETVAL_INVALID_DIR;
return;
}
}
break;
case OP_LIST:
do_list(device_names);
break;
case OP_GET:
for(i = 0;i < device_names->size;++i){
if(chdir(device_names->list[i])){
io_error_2(IO_ERROR_OPEN, IO_ERROR_DIR, device_dir, device_names->list[i]);
return_value = RETVAL_INVALID_DIR;
continue;
}
do_get(device_names->list[i]);
if(chdir(device_dir)){
io_error(IO_ERROR_OPEN, IO_ERROR_DIR, device_dir);
return_value = RETVAL_INVALID_DIR;
return;
}
}
break;
};
}
return changes;
}
//If a global operation is requested, run this to fill arg with all devices, each with the global operation
void populate_args(struct arg_values* arg, struct string_array* devices){
struct arg_values* curr = arg;
for(size_t i = 0;i < devices->size;++i){
curr->next = malloc(sizeof(struct arg_values));
curr->next->device = devices->list[i];
curr->next->delta = arg->delta;
curr->next->fade_duration = arg->fade_duration;
curr->next->fade_steps = arg->fade_steps;
curr->next->operation = arg->operation;
curr->next->flags = arg->flags;
curr = curr->next;
}
curr->next = NULL;
arg->num_values = devices->size;
}
@ -332,8 +309,7 @@ int main(int argc, char** argv){
struct arg_values args; //A linked list of devices and the requested settings.
struct string_array device_names; //List of all led/backlight devices in sysfs.
int should_save = 0;
struct arg_values* curr;
args = process_cmd_args(argc, argv);
if(args.operation == OP_USAGE){
usage(return_value);
@ -343,54 +319,53 @@ int main(int argc, char** argv){
device_names = get_device_sources();
//Macro for easy memory cleaning
#define CLEANUP() do{free_string_array(&device_names);free_cmd_args(&args);}while(0)
//If there are no led/backlights, we can't do anything
if(device_names.size == 0){
#ifdef REXBACKLIGHT
fprintf(stderr, "No backlight devices found!\n");
fprintf(stderr, "No backlights devices found!\n");
#elif defined(REXLEDCTL)
fprintf(stderr, "No led devices found!\n");
#else
#error "UNDEFINED PROGRAM NAME!"
#endif
free_string_array(&device_names);
free_cmd_args(&args);
CLEANUP();
return RETVAL_INVALID_DEVICE;
}
//Make sure all explicit devices actually exist
for(struct arg_values* curr = args.next;curr;curr = curr->next){
for(int i = 0;i < device_names.size;++i){
for(curr = args.next;curr;curr = curr->next){
int i;
for(i = 0;i < device_names.size;++i){
if(!strcmp(curr->device, device_names.list[i])){
goto continue_outer;
}
}
fprintf(stderr, "No such device '%s'\n", curr->device);
free_string_array(&device_names);
free_cmd_args(&args);
CLEANUP();
return RETVAL_INVALID_DEVICE;
continue_outer:;
}
//Change to the base directory for all sysfs leds/backlights
if(chdir(device_dir())){
io_error(IO_ERROR_READ, IO_ERROR_DIR, device_dir());
free_string_array(&device_names);
free_cmd_args(&args);
if(chdir(device_dir)){
io_error(IO_ERROR_READ, IO_ERROR_DIR, device_dir);
CLEANUP();
return RETVAL_INVALID_DIR;
}
//on a global operation, populate list with all devices
if(!args.next){
populate_args(&args, &device_names);
//Run selected operation
if(args.next){
individual_device_loop(&args);
}else{
all_device_loop(&device_names, &args);
}
should_save = (run_device_operations(&args) > 0);
#ifdef ENABLE_RESTORE_FILE
if(should_save)
save_restore_file(&device_names, &args); //performs cleanup on args
else
free_cmd_args(&args);
#else
free_cmd_args(&args);
#endif
free_string_array(&device_names);
CLEANUP();
return return_value;
}
#undef CLEANUP