1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <unistd.h>
#include <time.h>
#define BREATHING_INTERVAL 90 // in milliseconds
#define STRESS_THRESHOLD 8.0 // System load threshold for stress mode
// Default and stress colors
const char *default_colors[] = {
"#ffe667", // Yellow
"#f27049", // Orange
"#3dd762" // Green
};
const char *stress_colors[] = {
"#f60000", // Bright Red
"#8e0000", // Dark Red
"#a10000", // Muted Red
"#5a0000" // Deep Crimson
};
// Convert sRGB to Linear RGB
double srgb_to_linear(double value) {
if (value <= 0.04045)
return value / 12.92;
else
return pow((value + 0.055) / 1.055, 2.4);
}
// Convert Linear RGB to sRGB
double linear_to_srgb(double value) {
if (value <= 0.0031308)
return value * 12.92;
else
return 1.055 * pow(value, 1.0 / 2.4) - 0.055;
}
// Function to interpolate between two colors in linear RGB space
void interpolate_color(const char *color1, const char *color2, double t, char *output) {
unsigned int r1, g1, b1, r2, g2, b2;
double lr1, lg1, lb1, lr2, lg2, lb2, lr, lg, lb;
// Parse the input hex colors
sscanf(color1, "#%02x%02x%02x", &r1, &g1, &b1);
sscanf(color2, "#%02x%02x%02x", &r2, &g2, &b2);
// Convert sRGB to linear RGB
lr1 = srgb_to_linear(r1 / 255.0);
lg1 = srgb_to_linear(g1 / 255.0);
lb1 = srgb_to_linear(b1 / 255.0);
lr2 = srgb_to_linear(r2 / 255.0);
lg2 = srgb_to_linear(g2 / 255.0);
lb2 = srgb_to_linear(b2 / 255.0);
// Interpolate in linear RGB space
lr = lr1 + t * (lr2 - lr1);
lg = lg1 + t * (lg2 - lg1);
lb = lb1 + t * (lb2 - lb1);
// Convert back to sRGB
r1 = round(linear_to_srgb(lr) * 255);
g1 = round(linear_to_srgb(lg) * 255);
b1 = round(linear_to_srgb(lb) * 255);
// Output the interpolated color as hex
snprintf(output, 8, "#%02x%02x%02x", r1, g1, b1);
}
// Function to read system load
double get_system_load() {
double load;
FILE *f = fopen("/proc/loadavg", "r");
if (f) {
fscanf(f, "%lf", &load);
fclose(f);
} else {
perror("Failed to read /proc/loadavg");
load = 0.0;
}
return load;
}
// Function to update breathing color
void update_breathing_color() {
static int color_index = 0;
static double t = 0.0;
char new_color[8];
// Determine the current color set (default or stress)
const char **current_colors;
int num_colors;
if (get_system_load() > STRESS_THRESHOLD) {
current_colors = stress_colors;
num_colors = sizeof(stress_colors) / sizeof(stress_colors[0]);
} else {
current_colors = default_colors;
num_colors = sizeof(default_colors) / sizeof(default_colors[0]);
}
// Interpolate between the current and next color in the palette
interpolate_color(
current_colors[color_index],
current_colors[(color_index + 1) % num_colors],
t,
new_color
);
// Write the new color to the output file
FILE *f = fopen("/tmp/breathing_color", "w");
if (f) {
fprintf(f, "%s\n", new_color);
fclose(f);
}
// Update interpolation factor and color index
t += 0.02; // Adjust speed of interpolation here
if (t >= 1.0) {
t = 0.0;
color_index = (color_index + 1) % num_colors;
}
}
int main() {
struct timespec last_breathing_update = {0}, now;
// Initialize breathing colors
clock_gettime(CLOCK_MONOTONIC, &last_breathing_update);
while (1) {
clock_gettime(CLOCK_MONOTONIC, &now);
// Update breathing colors
double elapsed_breathing = (now.tv_sec - last_breathing_update.tv_sec) * 1000.0 +
(now.tv_nsec - last_breathing_update.tv_nsec) / 1.0e6;
if (elapsed_breathing >= BREATHING_INTERVAL) {
update_breathing_color();
last_breathing_update = now;
}
usleep(10000); // Sleep to prevent excessive CPU usage
}
return 0;
}
|
