static inline void apply(const Pixel<double, SrcColSpace>& src,
Pixel<T, DstColSpace>& dst)
{
Pixel<double, DstColSpace> double_dst;
convert_color(src, double_dst);
convert_channel<double, T, DstColSpace>(double_dst, dst);
}
static inline void apply(const Pixel<float, SrcColSpace>& src,
Pixel<T, DstColSpace>& dst)
{
Pixel<float, DstColSpace> float_dst;
convert_color(src, float_dst);
convert_channel<float, T, DstColSpace>(float_dst, dst);
}
static unsigned char term256_color_for_rgb(const unsigned char rgb[3]) {
const uint32_t kColors[240] = {
0x000000, 0x00005f, 0x000087, 0x0000af, 0x0000d7, 0x0000ff, 0x005f00, 0x005f5f,
0x005f87, 0x005faf, 0x005fd7, 0x005fff, 0x008700, 0x00875f, 0x008787, 0x0087af,
0x0087d7, 0x0087ff, 0x00af00, 0x00af5f, 0x00af87, 0x00afaf, 0x00afd7, 0x00afff,
0x00d700, 0x00d75f, 0x00d787, 0x00d7af, 0x00d7d7, 0x00d7ff, 0x00ff00, 0x00ff5f,
0x00ff87, 0x00ffaf, 0x00ffd7, 0x00ffff, 0x5f0000, 0x5f005f, 0x5f0087, 0x5f00af,
0x5f00d7, 0x5f00ff, 0x5f5f00, 0x5f5f5f, 0x5f5f87, 0x5f5faf, 0x5f5fd7, 0x5f5fff,
0x5f8700, 0x5f875f, 0x5f8787, 0x5f87af, 0x5f87d7, 0x5f87ff, 0x5faf00, 0x5faf5f,
0x5faf87, 0x5fafaf, 0x5fafd7, 0x5fafff, 0x5fd700, 0x5fd75f, 0x5fd787, 0x5fd7af,
0x5fd7d7, 0x5fd7ff, 0x5fff00, 0x5fff5f, 0x5fff87, 0x5fffaf, 0x5fffd7, 0x5fffff,
0x870000, 0x87005f, 0x870087, 0x8700af, 0x8700d7, 0x8700ff, 0x875f00, 0x875f5f,
0x875f87, 0x875faf, 0x875fd7, 0x875fff, 0x878700, 0x87875f, 0x878787, 0x8787af,
0x8787d7, 0x8787ff, 0x87af00, 0x87af5f, 0x87af87, 0x87afaf, 0x87afd7, 0x87afff,
0x87d700, 0x87d75f, 0x87d787, 0x87d7af, 0x87d7d7, 0x87d7ff, 0x87ff00, 0x87ff5f,
0x87ff87, 0x87ffaf, 0x87ffd7, 0x87ffff, 0xaf0000, 0xaf005f, 0xaf0087, 0xaf00af,
0xaf00d7, 0xaf00ff, 0xaf5f00, 0xaf5f5f, 0xaf5f87, 0xaf5faf, 0xaf5fd7, 0xaf5fff,
0xaf8700, 0xaf875f, 0xaf8787, 0xaf87af, 0xaf87d7, 0xaf87ff, 0xafaf00, 0xafaf5f,
0xafaf87, 0xafafaf, 0xafafd7, 0xafafff, 0xafd700, 0xafd75f, 0xafd787, 0xafd7af,
0xafd7d7, 0xafd7ff, 0xafff00, 0xafff5f, 0xafff87, 0xafffaf, 0xafffd7, 0xafffff,
0xd70000, 0xd7005f, 0xd70087, 0xd700af, 0xd700d7, 0xd700ff, 0xd75f00, 0xd75f5f,
0xd75f87, 0xd75faf, 0xd75fd7, 0xd75fff, 0xd78700, 0xd7875f, 0xd78787, 0xd787af,
0xd787d7, 0xd787ff, 0xd7af00, 0xd7af5f, 0xd7af87, 0xd7afaf, 0xd7afd7, 0xd7afff,
0xd7d700, 0xd7d75f, 0xd7d787, 0xd7d7af, 0xd7d7d7, 0xd7d7ff, 0xd7ff00, 0xd7ff5f,
0xd7ff87, 0xd7ffaf, 0xd7ffd7, 0xd7ffff, 0xff0000, 0xff005f, 0xff0087, 0xff00af,
0xff00d7, 0xff00ff, 0xff5f00, 0xff5f5f, 0xff5f87, 0xff5faf, 0xff5fd7, 0xff5fff,
0xff8700, 0xff875f, 0xff8787, 0xff87af, 0xff87d7, 0xff87ff, 0xffaf00, 0xffaf5f,
0xffaf87, 0xffafaf, 0xffafd7, 0xffafff, 0xffd700, 0xffd75f, 0xffd787, 0xffd7af,
0xffd7d7, 0xffd7ff, 0xffff00, 0xffff5f, 0xffff87, 0xffffaf, 0xffffd7, 0xffffff,
0x080808, 0x121212, 0x1c1c1c, 0x262626, 0x303030, 0x3a3a3a, 0x444444, 0x4e4e4e,
0x585858, 0x626262, 0x6c6c6c, 0x767676, 0x808080, 0x8a8a8a, 0x949494, 0x9e9e9e,
0xa8a8a8, 0xb2b2b2, 0xbcbcbc, 0xc6c6c6, 0xd0d0d0, 0xdadada, 0xe4e4e4, 0xeeeeee
};
return 16 + convert_color(rgb, kColors, sizeof kColors / sizeof *kColors);
}
inline void smart_convert_color(const Pixel<double, SrcColSpace>& src,
Pixel<float, DstColSpace>& dst)
{
Pixel<double, DstColSpace> double_dst;
convert_color(src, double_dst);
convert_channel<double, float, DstColSpace>(double_dst, dst);
}
inline void smart_convert_color(const Pixel<T, ColorSpace>& src, U& dst)
{
Pixel<double, ColorSpace> double_src;
double double_dst;
convert_channel<T, double, ColorSpace>(src, double_src);
convert_color(double_src, double_dst);
convert_channel(double_dst, dst);
}
inline void smart_convert_color(T src, Pixel<U, ColorSpace>& dst)
{
double double_src;
Pixel<double, ColorSpace> double_dst;
convert_channel(src, double_src);
convert_color(double_src, double_dst);
convert_channel<double, U, ColorSpace>(double_dst, dst);
}
inline void smart_convert_color(const Pixel<SrcT, SrcColSpace>& src,
Pixel<DstT, DstColSpace>& dst)
{
Pixel<double, SrcColSpace> double_src;
Pixel<double, DstColSpace> double_dst;
convert_channel<SrcT, double, SrcColSpace>(src, double_src);
convert_color(double_src, double_dst);
convert_channel<double, DstT, DstColSpace>(double_dst, dst);
}
void allocate_quake_player_colors (GdkWindow *window) {
GdkColormap *colormap;
int i, j;
if (!pcolors_allocated) {
colormap = gdk_window_get_colormap (window);
for (i = 0; i < 14; i++) {
j = (i<8)? 11 : 15 - 11;
pcolors[i].pixel = 0;
pcolors[i].red = convert_color (quake_pallete [(i*16 + j)*3 + 0]);
pcolors[i].green = convert_color (quake_pallete [(i*16 + j)*3 + 1]);
pcolors[i].blue = convert_color (quake_pallete [(i*16 + j)*3 + 2]);
if (!gdk_color_alloc (colormap, &pcolors[i])) {
g_warning ("unable to allocate color: ( %d %d %d )",
pcolors[i].red, pcolors[i].green, pcolors[i].blue);
}
}
pcolors_allocated = TRUE;
}
}
static unsigned char term8_color_for_rgb(const unsigned char rgb[3]) {
const uint32_t kColors[] = {
0x000000, //Black
0xFF0000, //Red
0x00FF00, //Green
0xFFFF00, //Yellow
0x0000FF, //Blue
0xFF00FF, //Magenta
0x00FFFF, //Cyan
0xFFFFFF, //White
};
return convert_color(rgb, kColors, sizeof kColors / sizeof *kColors);
}
int main()
{
// Initialize pins
init_leds();
init_spi();
// Init data buffer
data_buffer[0] = convert_color(1023,1023,1023);
data_buffer[1] = convert_color(512,512,512);
// Change byteorder
rewrite_byteorder(data_buffer, (uint16_t*) data_buffer, 2);
// Write two 32 bit integers
spi_write_buffer((uint16_t*) data_buffer, 2);
// wait a bit
wait_own(wait_led);
// Write some more colors
spi_write_int32(convert_color(1023,0,0));
wait_own(wait_led);
spi_write_int32(convert_color(0,1023,0));
wait_own(wait_led);
spi_write_int32(convert_color(0,0,1023));
wait_own(wait_led);
spi_write_int32(convert_color(0,0,0));
// Set end notification LED
GPIO_SetBits(GPIOD, GPIO_Pin_14);
while(1);
}
inline void smart_convert_color(const Pixel<double, SrcColSpace>& src,
Pixel<double, DstColSpace>& dst)
{
convert_color(src, dst);
}
static void
nemo_cell_renderer_disk_render (GtkCellRenderer *cell,
cairo_t *cr,
GtkWidget *widget,
const GdkRectangle *background_area,
const GdkRectangle *cell_area,
GtkCellRendererState flags)
{
NemoCellRendererDisk *cellprogress = NEMO_CELL_RENDERER_DISK (cell);
gint x, y, w;
gint xpad, ypad;
gint full;
gboolean show = cellprogress->show_disk_full_percent;
GtkStyleContext *context;
if (show) {
context = gtk_widget_get_style_context (widget);
GdkColor *gdk_bg_color, *gdk_fg_color;
GdkRGBA bg_color, fg_color;
gint bar_width, bar_radius, bottom_padding, max_length;
gtk_style_context_get_style (context,
"disk-full-bg-color", &gdk_bg_color,
"disk-full-fg-color", &gdk_fg_color,
"disk-full-bar-width", &bar_width,
"disk-full-bar-radius", &bar_radius,
"disk-full-bottom-padding", &bottom_padding,
"disk-full-max-length", &max_length,
NULL);
if (gdk_bg_color) {
convert_color (gdk_bg_color, &bg_color);
gdk_color_free (gdk_bg_color);
} else {
use_default_color (&bg_color);
}
if (gdk_fg_color) {
convert_color (gdk_fg_color, &fg_color);
gdk_color_free (gdk_fg_color);
} else {
use_default_color (&fg_color);
}
gtk_cell_renderer_get_padding (cell, &xpad, &ypad);
x = cell_area->x + xpad;
y = cell_area->y + cell_area->height - bar_width - bottom_padding;
w = cell_area->width - xpad * 2;
w = w < max_length ? w : max_length;
full = (int) (((float) cellprogress->disk_full_percent / 100.0) * (float) w);
gtk_style_context_save (context);
cairo_save (cr);
gdk_cairo_set_source_rgba (cr, &bg_color);
cairo_rectangle_with_radius_corners (cr, x, y, w, bar_width, bar_radius);
cairo_fill (cr);
cairo_restore (cr);
cairo_save (cr);
gdk_cairo_set_source_rgba (cr, &fg_color);
cairo_rectangle_with_radius_corners (cr, x, y, full, bar_width, bar_radius);
cairo_fill (cr);
cairo_restore (cr);
gtk_style_context_restore (context);
}
GTK_CELL_RENDERER_CLASS (parent_class)->render (cell,
cr,
widget,
background_area,
cell_area,
flags);
}
int do_local(xmlNodePtr doc )
{
char buffer[1024];
char resultmsg[32768]="";
unsigned int color=STAT_GREEN;
GError *error=NULL;
GDir *dir;
G_CONST_RETURN gchar *filename;
char path[PATH_MAX] = "/etc/upwatch.d/uw_local_scripts";
char cmd[PATH_MAX];
FILE *in;
char info[32768];
char buf[256];
xmlNodePtr node = (xmlNodePtr) newnode(doc, "local");
struct stat st;
struct timeval start, now;
/* measure the time it takes to perform all checks */
gettimeofday(&start, NULL);
/* Don't allow directories writable by others */
if (stat(path, &st) < 0) {
LOG(LOG_ERR,"Cannot check permissions for %s", path);
}
if ( (st.st_uid == getuid()) && (st.st_mode & 077) != 0 ) { /* we are world or group writable */
LOG(LOG_ERR,"%s has bad permissions, refusing to run the scripts", path);
return;
}
/* Ok the directory is safe enough, lets open it. */
dir = g_dir_open (path, 0, &error);
if (dir == NULL) {
LOG(LOG_ERR,"Cannot open %s", path); /* Should not be reached */
perror(path);
return;
}
/* set a strict umask for safety */
umask(077);
/* Time to traverse the directory */
while ((filename = g_dir_read_name(dir)) != NULL) {
char fullpath[PATH_MAX];
if (filename[0] == '.') continue; // skip '.', '..' and hidden files
sprintf(fullpath, "%s/%s", path, filename);
if (!g_file_test(fullpath, G_FILE_TEST_IS_EXECUTABLE)) {
LOG(LOG_WARNING,"Script %s is not executable, skipping.", fullpath);
continue;
}
if ( debug > 4 ) printf("Checking script %s\n", fullpath);
/* The script should not be writable by others */
if (stat(fullpath, &st) < 0) {
LOG(LOG_ERR,"Cannot check permissions for %s", fullpath);
continue;
}
if ( (st.st_uid == getuid()) && (st.st_mode & 077) != 0 ) { /* we are world or group writable */
LOG(LOG_ERR,"Script %s has insecure permissions, refusing it.", fullpath);
continue;
}
if ( debug > 4 ) printf("Script %s is ok\n", fullpath);
uw_setproctitle("Running check %s", fullpath);
char msgbuf[8192]="";
unsigned int mycolor=STAT_GREEN; /* Untill proven otherwise */
sprintf(cmd, "%s > /tmp/.uw_sysstat.tmp", fullpath);
LOG(LOG_INFO, cmd);
if ( debug > 4 ) printf("Running local check %s\n", fullpath);
system(cmd);
in = fopen("/tmp/.uw_sysstat.tmp", "r");
if (in) {
int linecount=0;
while (fgets(buf, sizeof(buf), in)) {
if ( linecount == 0 ) { /* First line contains the color of the check */
linecount++;
mycolor=convert_color(buf);
}
else { /* All the rest is part of the message */
snprintf(msgbuf, sizeof(msgbuf), "%s\n%s", msgbuf, buf);
}
}
} else {
strcpy(info, strerror(errno));
}
fclose(in);
unlink("tmp/.uw_sysstat.tmp");
/* If there is a message, put it into the big message. Prepend the script name. */
if (strlen( msgbuf ) != 0 ) {
snprintf(resultmsg, sizeof(resultmsg), "%s%s:%s\n", resultmsg, fullpath, msgbuf );
}
/* is this the highest color? */
if ( mycolor > color ) color = mycolor;
}
/* ok, we finished the scripts loop, set the results */
gettimeofday(&now, NULL);
char totalstring[16]=""; /* Big enough? */
snprintf( totalstring, sizeof(totalstring), "%f", ((float) timeval_diff(&now, &start)) * 0.000001);
xmlSetProp(node, "total", totalstring);
/* Here we set the color */
sprintf(buffer, "%d", color);
xmlSetProp(node, "color", buffer);
xmlNewTextChild(node, NULL, "info", resultmsg);
g_dir_close(dir);
return color;
}
inline void smart_convert_color(const Pixel<double, ColorSpace>& src,
double& dst)
{
convert_color(src, dst);
}
inline void smart_convert_color(const Pixel<double, ColorSpace>& src, T& dst)
{
double double_dst;
convert_color(src, double_dst);
convert_channel(double_dst, dst);
}
inline void smart_convert_color(double src, Pixel<double, ColorSpace>& dst)
{
convert_color(src, dst);
}
inline void smart_convert_color(double src, Pixel<T, ColorSpace>& dst)
{
Pixel<double, ColorSpace> double_dst;
convert_color(src, double_dst);
convert_channel<double, T, ColorSpace>(double_dst, dst);
}