321 lines
6.8 KiB
C
321 lines
6.8 KiB
C
// -*- mode: C; indent-tabs-mode: nil; -*-
|
|
|
|
#include "../config.h"
|
|
#include "color.h"
|
|
#include "display.h"
|
|
#include "screeninfo.h"
|
|
|
|
#ifdef HAVE_STDLIB_H
|
|
# include <stdlib.h>
|
|
#endif
|
|
|
|
static Bool cleancache = False;
|
|
static PyObject *colorcache;
|
|
|
|
// global color allocator/deallocator
|
|
typedef struct RGB {
|
|
PyObject_HEAD
|
|
int screen;
|
|
int r, g, b;
|
|
} RGB;
|
|
|
|
static void rgb_dealloc(PyObject* self)
|
|
{
|
|
PyObject_Del(self);
|
|
}
|
|
|
|
static int rgb_compare(PyObject *py1, PyObject *py2)
|
|
{
|
|
long result;
|
|
unsigned long p1, p2;
|
|
RGB *r1, *r2;
|
|
|
|
r1 = (RGB*) r1;
|
|
r2 = (RGB*) r2;
|
|
p1 = (r1->screen << 24 | r1->r << 16 | r1->g << 8 | r1->b) & 0x00ffffff;
|
|
p2 = (r2->screen << 24 | r2->r << 16 | r2->g << 8 | r2->b) & 0x00ffffff;
|
|
|
|
if (p1 < p2)
|
|
result = -1;
|
|
else if (p1 > p2)
|
|
result = 1;
|
|
else
|
|
result = 0;
|
|
return result;
|
|
}
|
|
|
|
static PyTypeObject RGB_Type = {
|
|
PyObject_HEAD_INIT(NULL)
|
|
0,
|
|
"RGB",
|
|
sizeof(RGB),
|
|
0,
|
|
rgb_dealloc, /*tp_dealloc*/
|
|
0, /*tp_print*/
|
|
0, /*tp_getattr*/
|
|
0, /*tp_setattr*/
|
|
rgb_compare, /*tp_compare*/
|
|
0, /*tp_repr*/
|
|
0, /*tp_as_number*/
|
|
0, /*tp_as_sequence*/
|
|
0, /*tp_as_mapping*/
|
|
0, /*tp_hash */
|
|
};
|
|
|
|
static PyObject *RGB_New(int screen, int r, int g, int b) {
|
|
RGB *self = (RGB*) PyObject_New(RGB, &RGB_Type);
|
|
self->screen = screen;
|
|
self->r = r;
|
|
self->g = g;
|
|
self->b = b;
|
|
return (PyObject*)self;
|
|
}
|
|
|
|
typedef struct PixelRef {
|
|
unsigned long p;
|
|
unsigned int count;
|
|
} PixelRef;
|
|
|
|
static PixelRef *PixelRef_New(unsigned long p) {
|
|
PixelRef* self = malloc(sizeof(PixelRef));
|
|
self->p = p;
|
|
self->count = 1;
|
|
return self;
|
|
}
|
|
|
|
static void OtkColor_ParseColorName(OtkColor *self) {
|
|
XColor xcol;
|
|
|
|
if (!self->colorname) {
|
|
fprintf(stderr, "OtkColor: empty colorname, cannot parse (using black)\n");
|
|
OtkColor_SetRGB(self, 0, 0, 0);
|
|
}
|
|
|
|
// get rgb values from colorname
|
|
xcol.red = 0;
|
|
xcol.green = 0;
|
|
xcol.blue = 0;
|
|
xcol.pixel = 0;
|
|
|
|
if (!XParseColor(OBDisplay->display, self->colormap,
|
|
PyString_AsString(self->colorname), &xcol)) {
|
|
fprintf(stderr, "BColor::allocate: color parse error: \"%s\"\n",
|
|
PyString_AsString(self->colorname));
|
|
OtkColor_SetRGB(self, 0, 0, 0);
|
|
return;
|
|
}
|
|
|
|
OtkColor_SetRGB(self, xcol.red >> 8, xcol.green >> 8, xcol.blue >> 8);
|
|
}
|
|
|
|
static void OtkColor_DoCacheCleanup() {
|
|
unsigned long *pixels;
|
|
int i;
|
|
unsigned int count;
|
|
PyObject *rgb, *pixref;
|
|
int ppos;
|
|
|
|
// ### TODO - support multiple displays!
|
|
if (!PyDict_Size(colorcache)) {
|
|
// nothing to do
|
|
return;
|
|
}
|
|
|
|
pixels = malloc(sizeof(unsigned long) * PyDict_Size(colorcache));
|
|
|
|
for (i = 0; i < ScreenCount(OBDisplay->display); i++) {
|
|
count = 0;
|
|
ppos = 0;
|
|
|
|
while (PyDict_Next(colorcache, &ppos, &rgb, &pixref)) {
|
|
if (((PixelRef*)pixref)->count != 0 || ((RGB*)rgb)->screen != i)
|
|
continue;
|
|
|
|
pixels[count++] = ((PixelRef*)pixref)->p;
|
|
PyDict_DelItem(colorcache, rgb);
|
|
free(pixref); // not really a PyObject, it just pretends
|
|
--ppos; // back up one in the iteration
|
|
}
|
|
|
|
if (count > 0)
|
|
XFreeColors(OBDisplay->display,
|
|
OtkDisplay_ScreenInfo(OBDisplay, i)->colormap,
|
|
pixels, count, 0);
|
|
}
|
|
|
|
free(pixels);
|
|
cleancache = False;
|
|
}
|
|
|
|
static void OtkColor_Allocate(OtkColor *self) {
|
|
XColor xcol;
|
|
PyObject *rgb, *pixref;
|
|
|
|
if (!OtkColor_IsValid(self)) {
|
|
if (!self->colorname) {
|
|
fprintf(stderr, "BColor: cannot allocate invalid color (using black)\n");
|
|
OtkColor_SetRGB(self, 0, 0, 0);
|
|
} else {
|
|
OtkColor_ParseColorName(self);
|
|
}
|
|
}
|
|
|
|
// see if we have allocated this color before
|
|
rgb = RGB_New(self->screen, self->red, self->green, self->blue);
|
|
pixref = PyDict_GetItem((PyObject*)colorcache, rgb);
|
|
if (pixref) {
|
|
// found
|
|
self->allocated = True;
|
|
self->pixel = ((PixelRef*)pixref)->p;
|
|
((PixelRef*)pixref)->count++;
|
|
return;
|
|
}
|
|
|
|
// allocate color from rgb values
|
|
xcol.red = self->red | self->red << 8;
|
|
xcol.green = self->green | self->green << 8;
|
|
xcol.blue = self->blue | self->blue << 8;
|
|
xcol.pixel = 0;
|
|
|
|
if (!XAllocColor(OBDisplay->display, self->colormap, &xcol)) {
|
|
fprintf(stderr, "BColor::allocate: color alloc error: rgb:%x/%x/%x\n",
|
|
self->red, self->green, self->blue);
|
|
xcol.pixel = 0;
|
|
}
|
|
|
|
self->pixel = xcol.pixel;
|
|
self->allocated = True;
|
|
|
|
PyDict_SetItem(colorcache, rgb, (PyObject*)PixelRef_New(self->pixel));
|
|
|
|
if (cleancache)
|
|
OtkColor_DoCacheCleanup();
|
|
}
|
|
|
|
static void OtkColor_Deallocate(OtkColor *self) {
|
|
PyObject *rgb, *pixref;
|
|
|
|
if (!self->allocated)
|
|
return;
|
|
|
|
rgb = RGB_New(self->screen, self->red, self->green, self->blue);
|
|
pixref = PyDict_GetItem(colorcache, rgb);
|
|
if (pixref) {
|
|
if (((PixelRef*)pixref)->count >= 1)
|
|
((PixelRef*)pixref)->count--;
|
|
}
|
|
|
|
if (cleancache)
|
|
OtkColor_DoCacheCleanup();
|
|
|
|
self->allocated = False;
|
|
}
|
|
|
|
|
|
OtkColor *OtkColor_New(int screen)
|
|
{
|
|
OtkColor *self = malloc(sizeof(OtkColor));
|
|
|
|
self->allocated = False;
|
|
self->red = -1;
|
|
self->green = -1;
|
|
self->blue = -1;
|
|
self->pixel = 0;
|
|
self->screen = screen;
|
|
self->colorname = NULL;
|
|
self->colormap = OtkDisplay_ScreenInfo(OBDisplay, self->screen)->colormap;
|
|
|
|
return self;
|
|
}
|
|
|
|
OtkColor *OtkColor_FromRGB(int r, int g, int b, int screen)
|
|
{
|
|
OtkColor *self = malloc(sizeof(OtkColor));
|
|
|
|
self->allocated = False;
|
|
self->red = r;
|
|
self->green = g;
|
|
self->blue = b;
|
|
self->pixel = 0;
|
|
self->screen = screen;
|
|
self->colorname = NULL;
|
|
self->colormap = OtkDisplay_ScreenInfo(OBDisplay, self->screen)->colormap;
|
|
|
|
return self;
|
|
}
|
|
|
|
OtkColor *OtkColor_FromName(const char *name, int screen)
|
|
{
|
|
OtkColor *self = malloc(sizeof(OtkColor));
|
|
|
|
self->allocated = False;
|
|
self->red = -1;
|
|
self->green = -1;
|
|
self->blue = -1;
|
|
self->pixel = 0;
|
|
self->screen = screen;
|
|
self->colorname = PyString_FromString(name);
|
|
self->colormap = OtkDisplay_ScreenInfo(OBDisplay, self->screen)->colormap;
|
|
|
|
return self;
|
|
}
|
|
|
|
void OtkColor_Destroy(OtkColor *self)
|
|
{
|
|
if (self->colorname)
|
|
Py_DECREF(self->colorname);
|
|
free(self);
|
|
}
|
|
|
|
void OtkColor_SetRGB(OtkColor *self, int r, int g, int b)
|
|
{
|
|
OtkColor_Deallocate(self);
|
|
self->red = r;
|
|
self->green = g;
|
|
self->blue = b;
|
|
}
|
|
|
|
void OtkColor_SetScreen(OtkColor *self, int screen)
|
|
{
|
|
if (screen == self->screen) {
|
|
// nothing to do
|
|
return;
|
|
}
|
|
|
|
Otk_Deallocate(self);
|
|
|
|
self->colormap = OtkDisplay_ScreenInfo(OBDisplay, self->screen)->colormap;
|
|
|
|
self->screen = screen;
|
|
|
|
if (self->colorname)
|
|
parseColorName();
|
|
}
|
|
|
|
Bool OtkColor_IsValid(OtkColor *self)
|
|
{
|
|
return self->red != -1 && self->blue != -1 && self->green != -1;
|
|
}
|
|
|
|
unsigned long OtkColor_Pixel(OtkColor *self)
|
|
{
|
|
if (!self->allocated)
|
|
OtkColor_Allocate(self);
|
|
return self->pixel;
|
|
}
|
|
|
|
void OtkColor_InitializeCache()
|
|
{
|
|
colorcache = PyDict_New();
|
|
}
|
|
|
|
void OtkColor_DestroyCache()
|
|
{
|
|
Py_DECREF(colorcache);
|
|
colorcache = NULL;
|
|
}
|
|
|
|
void OtkColor_CleanupColorCache()
|
|
{
|
|
cleancache = True;
|
|
}
|