void
gib_imlib_image_fill_rectangle(Imlib_Image im, int x, int y, int w, int h,
int r, int g, int b, int a)
{
imlib_context_set_image(im);
imlib_context_set_color(r, g, b, a);
imlib_image_fill_rectangle(x, y, w, h);
}
/* set imlib color */
void ssocr_set_color(fg_bg_t color)
{
switch(color) {
case FG:
imlib_context_set_color(ssocr_foreground, ssocr_foreground,
ssocr_foreground, 255);
break;
case BG:
imlib_context_set_color(ssocr_background, ssocr_background,
ssocr_background, 255);
break;
default:
fprintf(stderr, "error: ssocr_set_color(): unknown color %d\n",
color);
exit(99);
break;
}
}
static void
EFont_draw_string(EImage * im, EFont * f, int x, int y,
int r, int g, int b, const char *text)
{
imlib_context_set_image(im);
imlib_context_set_color(r, g, b, 255);
imlib_context_set_font(f);
imlib_text_draw(x, y - imlib_get_maximum_font_ascent(), text);
}
void render_present()
{
update_bg();
#ifdef WITH_COMPOSITE
if (theme->use_composite) {
/*
* Because XRender can't do directly SRCc * SRCa + DSTc * (1 - SRCa) blending,
* I must apply SRCa to my SRCc manually. To do this I'm using PictOpSrc with
* alpha channel in mask. So, I need to copy RGB data to one buffer (color) and
* Alpha to another buffer (mask), then use them in XRenderComposite.
*
* But I think in can be done on theme loading stage. Just apply SRCa to SRCc
* immediately. Optimization?
*/
/* copy color part to bbcolor */
imlib_context_set_image(bbcolor);
imlib_image_set_has_alpha(1);
imlib_context_set_color(0,0,0,255);
imlib_image_fill_rectangle(0,0,bbwidth,bbheight);
imlib_blend_image_onto_image(bb,0,0,0,bbwidth,bbheight,0,0,bbwidth,bbheight);
imlib_context_set_drawable(pixcolor);
imlib_render_image_on_drawable(0,0);
/* copy alpha part to bbalpha */
imlib_context_set_image(bbalpha);
imlib_image_copy_alpha_to_image(bb,0,0);
imlib_image_set_has_alpha(1);
imlib_context_set_drawable(pixalpha);
imlib_render_image_on_drawable(0,0);
XRenderComposite(bbdpy,
PictOpSrc,
piccolor,
picalpha,
rootpic,
0, 0, 0, 0, 0, 0, bbwidth,
bbheight);
} else
#endif
if (*rootpmap) {
imlib_context_set_image(bbcolor);
imlib_blend_image_onto_image(bg,0,0,0,bbwidth,bbheight,0,0,bbwidth,bbheight);
imlib_context_set_blend(1);
imlib_blend_image_onto_image(bb,0,0,0,bbwidth,bbheight,0,0,bbwidth,bbheight);
imlib_context_set_blend(0);
imlib_context_set_drawable(bbwin);
imlib_render_image_on_drawable(0,0);
} else {
imlib_context_set_drawable(bbwin);
imlib_context_set_image(bb);
imlib_render_image_on_drawable(0,0);
}
}
static void render_checkerboard() {
/* create the checkerboard texture, if not already done. */
static Pixmap checks_pmap = None;
Imlib_Image checks = NULL;
if (checks_pmap == None) {
checks = imlib_create_image(16, 16);
if (!checks) {
fputs("Unable to create a teeny weeny imlib image. I detect problems\n", stderr);
}
imlib_context_set_image(checks);
imlib_context_set_color(144, 144, 144, 255);
imlib_image_fill_rectangle(0, 0, 16, 16);
imlib_context_set_color(100, 100, 100, 255);
imlib_image_fill_rectangle(0, 0, 8, 8);
imlib_image_fill_rectangle(8, 8, 8, 8);
checks_pmap = XCreatePixmap(x11.display, x11_window, 16, 16, x11.depth);
imlib_context_set_drawable(checks_pmap);
imlib_render_image_on_drawable(0, 0);
imlib_free_image_and_decache();
}
/* and plot the checkerboards onto the pixmap */
static GC gc = None;
XGCValues gcval;
if (gc == None) {
gcval.tile = checks_pmap;
gcval.fill_style = FillTiled;
gc = XCreateGC(x11.display, x11_window, GCTile | GCFillStyle, &gcval);
}
XFillRectangle(x11.display, window_pixmap, gc, 0, 0, s_view.win_width, s_view.win_height);
}
static tvalue im2_blank_image(struct sequ_image *img)
{
if(!img)
return FALSE;
imlib_context_set_image((Imlib_Image)img->privdata);
imlib_context_set_color(0,0,0,255);
imlib_image_fill_rectangle(0,0,img->width,img->height);
return TRUE;
}
void
gib_imlib_image_fill_polygon(Imlib_Image im, ImlibPolygon poly, int r, int g,
int b, int a, unsigned char alias, int cx,
int cy, int cw, int ch)
{
imlib_context_set_image(im);
imlib_context_set_color(r, g, b, a);
imlib_context_set_anti_alias(alias);
imlib_context_set_cliprect(cx, cy, cw, ch);
imlib_image_fill_polygon(poly);
imlib_context_set_cliprect(0, 0, 0, 0);
}
void
Rterm_draw_screen_string_imlib2(struct R_termscreen *screen, int row, int column, int len)
{
R_text_t *text;
R_textflags_t *textflags;
int bufferrow;
int bgcolor, fgcolor;
int textw, texth;
struct imlib2color *color;
Imlib_Image *textimg;
if (screen == NULL) {
return;
}
text = screen->textbuf.data[screen->viewrow + row] + column;
textflags = screen->textbuf.renddata[screen->viewrow + row] + column;
memcpy(screen->stringbuffer, text, len);
screen->stringbuffer[len] = '\0';
fprintf(stderr, "string: %s\n", screen->stringbuffer);
fgcolor = RTERM_CHAR_FG_COLOR(*textflags);
if (fgcolor) {
color = &screen->im2colors[fgcolor];
} else {
color = &screen->im2colors[RTERM_SCREEN_FOREGROUND];
}
#if 0
fprintf(stderr, "red == %d, green == %d, blue == %d, alpha == %d\n",
color->red, color->green, color->blue, color->alpha);
#endif
imlib_context_set_font(screen->im2font);
imlib_context_set_color(color->red, color->green, color->blue,
color->alpha);
imlib_context_set_drawable(screen->buf);
imlib_get_text_size(screen->stringbuffer,
&textw, &texth);
textimg = imlib_create_image(textw, texth);
imlib_context_set_image(textimg);
imlib_image_clear();
imlib_image_set_has_alpha(1);
imlib_context_set_blend(0);
imlib_context_set_anti_alias(0);
imlib_text_draw(0,
0,
screen->stringbuffer);
imlib_render_image_on_drawable(Rterm_screen_column_x(screen, column),
Rterm_screen_row_y(screen, column));
imlib_free_image();
return;
}
static inline PyObject *
ImageObject_set_color(PyObject* self, PyObject *args)
{
int red, green, blue, alpha=255;
if (!PyArg_ParseTuple(args, "(iiii):set_color", &red, &green, &blue, &alpha)){
return NULL;
}
imlib_context_set_image(((ImageObject *)self)->image);
imlib_context_set_color(red, green, blue, alpha);
Py_RETURN_NONE;
}
void draw_button_left_border(int x, int y, int height) {
Imlib_Image buffer;
buffer = imlib_create_image(border_width, height);
if ( buffer == NULL ) {
fprintf(stderr, "Null buffer second %d, %d\n", x, height);
return;
}
imlib_context_set_image(buffer);
imlib_context_set_color(0,0,0,255);
imlib_image_draw_line (0, 0, 0, height, 0);
imlib_render_image_on_drawable(x, y);
imlib_free_image();
}
void draw_button_bottom_border(int x, int y, int width) {
Imlib_Image buffer;
buffer = imlib_create_image(width, border_height);
if ( buffer == NULL ) {
fprintf(stderr, "Null buffer third %d, %d\n", x, width);
return;
}
imlib_context_set_image(buffer);
imlib_context_set_color(0,0,0,255);
imlib_image_draw_line (0, 0, width, 0, 0);
imlib_render_image_on_drawable(x, y);
imlib_free_image();
}
/* rotate the image */
Imlib_Image rotate(Imlib_Image *source_image, double theta)
{
Imlib_Image new_image; /* construct filtered image here */
Imlib_Image current_image; /* save image pointer */
int height, width; /* image dimensions */
int x,y; /* iteration variables / target coordinates */
int sx,sy; /* source coordinates */
Imlib_Color color_return; /* for imlib_query_pixel() */
/* save pointer to current image */
current_image = imlib_context_get_image();
/* create a new image */
imlib_context_set_image(*source_image);
height = imlib_image_get_height();
width = imlib_image_get_width();
new_image = imlib_clone_image();
/* convert theta from degrees to radians */
theta = theta / 360 * 2.0 * M_PI;
/* create rotated image
* (some parts of the original image will be lost) */
for(x = 0; x < width; x++) {
for(y = 0; y < height; y++) {
sx = (x-width/2) * cos(theta) + (y-height/2) * sin(theta) + width/2;
sy = (y-height/2) * cos(theta) - (x-width/2) * sin(theta) + height/2;
if((sx >= 0) && (sx <= width) && (sy >= 0) && (sy <= height)) {
imlib_image_query_pixel(sx, sy, &color_return);
imlib_context_set_image(new_image);
imlib_context_set_color(color_return.red, color_return.green, color_return.blue, color_return.alpha);
} else {
imlib_context_set_image(new_image);
ssocr_set_color(BG);
}
imlib_image_draw_pixel(x,y,0);
imlib_context_set_image(*source_image);
}
}
/* restore image from before function call */
imlib_context_set_image(current_image);
/* return filtered image */
return new_image;
}
void feh_menu_draw_submenu_at(int x, int y, Imlib_Image dst, int ox, int oy)
{
ImlibPolygon poly;
x -= ox;
y -= oy;
imlib_context_set_image(dst);
poly = imlib_polygon_new();
imlib_polygon_add_point(poly, x, y + 3);
imlib_polygon_add_point(poly, x + 3, y + 6);
imlib_polygon_add_point(poly, x, y + 9);
imlib_context_set_color(0, 0, 0, 255);
imlib_image_fill_polygon(poly);
imlib_polygon_free(poly);
return;
}
Imlib_Image scale_icon(Imlib_Image original, int icon_size)
{
Imlib_Image icon_scaled;
if (original) {
imlib_context_set_image (original);
icon_scaled = imlib_create_cropped_scaled_image(0, 0, imlib_image_get_width(), imlib_image_get_height(), icon_size, icon_size);
imlib_context_set_image (icon_scaled);
imlib_image_set_has_alpha(1);
DATA32* data = imlib_image_get_data();
adjust_asb(data, icon_size, icon_size, launcher_alpha, (float)launcher_saturation/100, (float)launcher_brightness/100);
imlib_image_put_back_data(data);
} else {
icon_scaled = imlib_create_image(icon_size, icon_size);
imlib_context_set_image (icon_scaled);
imlib_context_set_color(255, 255, 255, 255);
imlib_image_fill_rectangle(0, 0, icon_size, icon_size);
}
return icon_scaled;
}
/* shear the image
* the top line is unchanged
* the bottom line is moved offset pixels to the right
* the other lines are moved yPos*offset/(height-1) pixels to the right
* white pixels are inserted at the left side */
Imlib_Image shear(Imlib_Image *source_image, int offset)
{
Imlib_Image new_image; /* construct filtered image here */
Imlib_Image current_image; /* save image pointer */
int height, width; /* image dimensions */
int x,y; /* iteration variables */
int shift; /* current shift-width */
Imlib_Color color_return; /* for imlib_query_pixel() */
/* save pointer to current image */
current_image = imlib_context_get_image();
/* create a new image */
imlib_context_set_image(*source_image);
height = imlib_image_get_height();
width = imlib_image_get_width();
new_image = imlib_clone_image();
/* move every line to the right */
for(y=1; y<height; y++) {
shift = y * offset / (height-1);
/* copy pixels */
for(x=width-1; x>=shift; x--) {
imlib_image_query_pixel(x-shift, y, &color_return);
imlib_context_set_image(new_image);
imlib_context_set_color(color_return.red, color_return.green,
color_return.blue, color_return.alpha);
imlib_image_draw_pixel(x,y,0);
imlib_context_set_image(*source_image);
}
/* fill with background */
for(x=0; x<shift; x++) {
draw_bg_pixel(new_image, x, y);
}
}
/* restore image from before function call */
imlib_context_set_image(current_image);
/* return filtered image */
return new_image;
}
/* set up imlib and X */
void
setup(char *paths[], int c, const char *col) {
Visual *vis;
Colormap cm;
XColor color;
int i, screen;
/* Loading images */
for(nimage = i = 0; i < c && i < LENGTH(images); i++) {
if((images[nimage] = imlib_load_image_without_cache(paths[i])))
nimage++;
else {
fprintf(stderr, "Warning: Cannot load file `%s`. "
"Ignoring.\n", paths[nimage]);
continue;
}
}
if(nimage == 0)
die("Error: No image to draw.\n");
/* set up X */
screen = DefaultScreen(dpy);
vis = DefaultVisual(dpy, screen);
cm = DefaultColormap(dpy, screen);
root = RootWindow(dpy, screen);
XSelectInput(dpy, root, StructureNotifyMask);
sx = sy = 0;
sw = DisplayWidth(dpy, screen);
sh = DisplayHeight(dpy, screen);
if(!XAllocNamedColor(dpy, cm, col, &color, &color))
die("Error: Cannot allocate color.\n");
/* set up Imlib */
imlib_context_set_display(dpy);
imlib_context_set_visual(vis);
imlib_context_set_colormap(cm);
imlib_context_set_color(color.red, color.green, color.blue, 255);
}
Imlib_Image Get_Image_from_ImgArray(struct CamGrab_t* CG)
{
int localMostRecent;
if (CG->MostRecent < 0)
{ //create dummy image to display
CG->LastDisplayedImage = imlib_create_image(640, 480);
imlib_context_set_image(CG->LastDisplayedImage);
imlib_context_set_color(128, 128, 128, 255);
imlib_image_fill_rectangle(0, 0, 640, 480);
}
else
{ //grab threads have started receiving images from rover
pthread_mutex_lock(&CG->MostRecentLock);
localMostRecent = CG->MostRecent;
pthread_mutex_lock(&CG->ImgArrayLock[CG->MostRecent]);
pthread_mutex_unlock(&CG->MostRecentLock);
imlib_context_set_image(*CG->ImgArray[localMostRecent]);
CG->LastDisplayedImage = imlib_clone_image();
CG->LastDisplayed = localMostRecent;
pthread_mutex_unlock(&CG->ImgArrayLock[localMostRecent]);
}
return CG->LastDisplayedImage;
}
/* turn image to grayscale */
Imlib_Image grayscale(Imlib_Image *source_image, luminance_t lt)
{
Imlib_Image new_image; /* construct grayscale image here */
Imlib_Image current_image; /* save image pointer */
int height, width; /* image dimensions */
int x,y; /* iteration variables */
Imlib_Color color; /* Imlib2 color structure */
int lum=0;
/* save pointer to current image */
current_image = imlib_context_get_image();
/* create a new image */
imlib_context_set_image(*source_image);
height = imlib_image_get_height();
width = imlib_image_get_width();
new_image = imlib_clone_image();
/* transform image to grayscale */
for(x=0; x<width; x++) {
for(y=0; y<height; y++) {
imlib_context_set_image(*source_image);
imlib_image_query_pixel(x, y, &color);
imlib_context_set_image(new_image);
lum = clip(get_lum(&color, lt),0,255);
imlib_context_set_color(lum, lum, lum, color.alpha);
imlib_image_draw_pixel(x, y, 0);
}
}
/* restore image from before function call */
imlib_context_set_image(current_image);
/* return filtered image */
return new_image;
}
void
menu_draw_string_imlib2(Rwindow_t *window)
{
int textw, texth;
unsigned int winw, winh;
unsigned int dummyui;
int dummyi;
size_t len;
char *str;
Window dummywin;
Imlib_Image textimg;
char blend;
if (window->im2title) {
XGetGeometry(window->app->display, window->id, &dummywin,
&dummyi, &dummyi, &winw, &winh, &dummyui, &dummyui);
imlib_context_set_image(window->im2title);
imlib_context_set_drawable(window->id);
blend = imlib_context_get_blend();
imlib_context_set_blend(1);
imlib_render_image_on_drawable(window->menu->lefttextoffset,
(winh - window->im2titleh) / 2);
if (window->menuitem) {
textimg = NULL;
if (window->menuitem->type == MENUITEM_TOGGLE) {
if (!window->menuitem->im2true) {
imlib_context_set_font(window->im2font);
imlib_get_text_size(window->menuitem->truetext,
&textw, &texth);
textimg = imlib_create_image(textw, texth);
if (textimg) {
imlib_context_set_image(textimg);
imlib_image_set_has_alpha(1);
imlib_image_clear();
imlib_context_set_color(204, 181, 59, 255);
imlib_text_draw(0, 0, window->menuitem->truetext);
window->menuitem->im2true = textimg;
window->menuitem->im2truew = textw;
window->menuitem->im2trueh = texth;
}
}
if (!window->menuitem->im2false) {
imlib_context_set_font(window->im2font);
imlib_get_text_size(window->menuitem->falsetext,
&textw, &texth);
textimg = imlib_create_image(textw, texth);
if (textimg) {
imlib_context_set_image(textimg);
imlib_image_set_has_alpha(1);
imlib_image_clear();
imlib_context_set_color(204, 181, 59, 255);
imlib_text_draw(0, 0, window->menuitem->falsetext);
window->menuitem->im2false = textimg;
window->menuitem->im2falsew = textw;
window->menuitem->im2falseh = texth;
}
}
if (*((unsigned long *)window->menuitem->option.valueptr)
& window->menuitem->option.flag) {
str = window->menuitem->truetext;
textimg = window->menuitem->im2true;
textw = window->menuitem->im2truew;
texth = window->menuitem->im2trueh;
} else {
str = window->menuitem->falsetext;
textimg = window->menuitem->im2false;
textw = window->menuitem->im2falsew;
texth = window->menuitem->im2falseh;
}
} else if (window->menuitem->righttext) {
if (!window->menuitem->im2right) {
imlib_context_set_font(window->im2font);
imlib_get_text_size(window->menuitem->righttext,
&textw, &texth);
textimg = imlib_create_image(textw, texth);
if (textimg) {
imlib_context_set_image(textimg);
imlib_image_set_has_alpha(1);
imlib_image_clear();
imlib_context_set_color(204, 181, 59, 255);
imlib_text_draw(0, 0, window->menuitem->righttext);
window->menuitem->im2right = textimg;
window->menuitem->im2rightw = textw;
window->menuitem->im2righth = texth;
}
}
str = window->menuitem->righttext;
textimg = window->menuitem->im2right;
textw = window->menuitem->im2rightw;
texth = window->menuitem->im2righth;
}
if (textimg) {
imlib_context_set_image(textimg);
imlib_context_set_drawable(window->id);
imlib_render_image_on_drawable(winw - window->menu->righttextoffset - textw,
(winh - texth) / 2);
} else {
#if 0
len = strlen(str);
if (len) {
XDrawString(window->app->display, window->id, window->gc,
winw - window->menu->righttextoffset
- len * FONT_WIDTH(window->fontinfo),
(winh + FONT_HEIGHT(window->fontinfo)) / 2,
str, len);
}
#endif
}
}
imlib_context_set_blend(blend);
} else {
menu_draw_string(window);
}
return;
}
/* gray stretching, i.e. lum<t1 => lum=0, lum>t2 => lum=100,
* else lum=((lum-t1)*MAXRGB)/(t2-t1) */
Imlib_Image gray_stretch(Imlib_Image *source_image, double t1, double t2,
luminance_t lt)
{
Imlib_Image new_image; /* construct filtered image here */
Imlib_Image current_image; /* save image pointer */
int height, width; /* image dimensions */
int x,y; /* iteration variables */
Imlib_Color color;
int lum; /* luminance value of pixel */
/* do nothing if t1>=t2 */
if(t1 >= t2) {
fprintf(stderr, "error: gray_stretch(): t1=%.2f >= t2=%.2f\n", t1, t2);
exit(99);
}
/* check if 0 < t1,t2 < MAXRGB */
if(t1 <= 0.0) {
fprintf(stderr, "error: gray_stretch(): t1=%.2f <= 0.0\n", t1);
exit(99);
}
if(t2 >= MAXRGB) {
fprintf(stderr, "error: gray_stretch(): t2=%.2f >= %d.0\n", t2, MAXRGB);
exit(99);
}
/* save pointer to current image */
current_image = imlib_context_get_image();
/* create a new image */
imlib_context_set_image(*source_image);
height = imlib_image_get_height();
width = imlib_image_get_width();
new_image = imlib_clone_image();
/* gray stretch image */
for(x=0; x<width; x++) {
for(y=0; y<height; y++) {
imlib_image_query_pixel(x, y, &color);
lum = get_lum(&color, lt);
imlib_context_set_image(new_image);
if(lum<=t1) {
imlib_context_set_color(0, 0, 0, color.alpha);
} else if(lum>=t2) {
imlib_context_set_color(MAXRGB, MAXRGB, MAXRGB, color.alpha);
} else {
imlib_context_set_color(clip(((lum-t1)*255)/(t2-t1),0,255),
clip(((lum-t1)*255)/(t2-t1),0,255),
clip(((lum-t1)*255)/(t2-t1),0,255),
color.alpha);
}
imlib_image_draw_pixel(x, y, 0);
imlib_context_set_image(*source_image);
}
}
/* restore image from before function call */
imlib_context_set_image(current_image);
/* return filtered image */
return new_image;
}
void Resources::reloadWallpaper()
{
if (!_wallpaper)
delete _wallpaper;
Window rootWindow = XTools::rootWindow();
XWindowAttributes attrs;
XGetWindowAttributes(_dpy, rootWindow, &attrs);
int width = attrs.width;
int height = attrs.height;
_wallpaper = new Image(_dpy, width, height, attrs.depth);
printf("Loading background from '%s'\n", Settings::instance()->backgroundFilename());
printf("Background mode: %d\n", Settings::instance()->backgroundMode());
imlib_context_set_display(_dpy);
int bgXpos = 0;
int bgYpos = 0;
Imlib_Image background = imlib_load_image(Settings::instance()->backgroundFilename());
if (background == 0)
{
printf("Cannot load background\n");
printf("rgb = (%d, %d, %d)\n",
_backgroundColor.red / 256,
_backgroundColor.green / 256,
_backgroundColor.blue / 256
);
background = imlib_create_image(width, height);
imlib_context_set_image(background);
imlib_context_set_color(
_backgroundColor.red / 256,
_backgroundColor.green / 256,
_backgroundColor.blue / 256,
255
);
imlib_image_fill_rectangle(0, 0, width, height);
}
else
{
Imlib_Image bgToDraw = 0;
imlib_context_set_image(background);
switch (Settings::instance()->backgroundMode())
{
case Settings::Stretched:
{
bgToDraw = imlib_create_cropped_scaled_image(
0, 0,
imlib_image_get_width(), imlib_image_get_height(),
width, height
);
break;
}
case Settings::Centered:
{
// Hildon's logic is not so easy in this case
// bgToDraw = imlib_create_cropped_image(
// (imlib_image_get_width() - width) / 2,
// (imlib_image_get_height()- height) / 2,
// width, height
// );
double scalex = 1.0;
double scaley = 1.0;
if (imlib_image_get_width() > width * 2)
scalex = (double)imlib_image_get_width() / 2.0 / width;
if (imlib_image_get_height() > height * 2)
scaley = (double)imlib_image_get_height() / 2.0 / height;
double scale = scalex;
if (scaley > scale)
scale = scaley;
int newwidth = (int)(scale * width);
int newheight= (int)(scale * height);
bgToDraw = imlib_create_cropped_scaled_image(
(imlib_image_get_width() - newwidth) / 2,
(imlib_image_get_height()- newheight)/ 2,
newwidth, newheight,
width, height
);
break;
}
case Settings::Scaled: case Settings::Cropped:
{
double scalex = (double)width / imlib_image_get_width();
double scaley = (double)height / imlib_image_get_height();
double scale = scalex;
if (Settings::instance()->backgroundMode() == Settings::Scaled)
{
if (scaley < scale) scale = scaley;
}
else
{
if (scaley > scale) scale = scaley;
}
int newwidth = (int)(imlib_image_get_width() * scale);
int newheight= (int)(imlib_image_get_height() * scale);
bgToDraw = imlib_create_cropped_scaled_image(
0, 0,
imlib_image_get_width(), imlib_image_get_height(),
newwidth, newheight
);
bgXpos = (width - newwidth) / 2;
bgYpos = (height - newheight) / 2;
break;
}
default:
printf("Unknown background mode: %d\n", Settings::instance()->backgroundMode());
}
imlib_free_image();
imlib_context_set_image(bgToDraw);
}
imlib_context_set_drawable(_wallpaper->pixmap());
imlib_context_set_visual(DefaultVisual(_dpy, DefaultScreen(_dpy)));
imlib_render_image_on_drawable(bgXpos, bgYpos);
imlib_free_image();
}
ngx_int_t ngx_http_small_light_imlib2_process(ngx_http_request_t *r, ngx_http_small_light_ctx_t *ctx)
{
ngx_http_small_light_imlib2_ctx_t *ictx;
ngx_http_small_light_image_size_t sz;
Imlib_Image image_org, image_dst, image_tmp;
Imlib_Load_Error err;
ngx_file_info_t fi;
ngx_fd_t fd;
char *filename, *sharpen, *blur, *of, *buf;
void *data;
int w, h, radius, orientation;
double iw, ih, q;
ngx_int_t type;
const char *ext;
ssize_t size;
ictx = (ngx_http_small_light_imlib2_ctx_t *)ctx->ictx;
filename = (char *)ictx->tf->file.name.data;
/* adjust image size */
ngx_http_small_light_calc_image_size(r, ctx, &sz, 10000.0, 10000.0);
if (sz.jpeghint_flg != 0) {
if (ngx_http_small_light_load_jpeg((void**)&data, &w, &h, r, filename, sz.dw, sz.dh) != NGX_OK) {
image_org = imlib_load_image_immediately_without_cache(filename);
if (image_org == NULL) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"failed to load image %s:%d",
__FUNCTION__,
__LINE__);
return NGX_ERROR;
}
} else {
image_org = imlib_create_image_using_data(w, h, data);
}
} else {
image_org = imlib_load_image_immediately_without_cache(filename);
if (image_org == NULL) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"failed to load image %s:%d",
__FUNCTION__,
__LINE__);
return NGX_ERROR;
}
}
/* rotate. */
if (sz.angle) {
orientation = 0;
switch (sz.angle) {
case 90:
orientation = 1;
break;
case 180:
orientation = 2;
break;
case 270:
orientation = 3;
break;
default:
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"image not rotated. 'angle'(%d) must be 90 or 180 or 270. %s:%d",
sz.angle,
__FUNCTION__,
__LINE__);
break;
}
imlib_context_set_image(image_org);
imlib_image_orientate(orientation);
}
/* calc size. */
imlib_context_set_image(image_org);
iw = (double)imlib_image_get_width();
ih = (double)imlib_image_get_height();
ngx_http_small_light_calc_image_size(r, ctx, &sz, iw, ih);
/* pass through. */
if (sz.pt_flg != 0) {
ctx->of = ctx->inf;
return NGX_OK;
}
/* crop, scale. */
if (sz.scale_flg != 0) {
image_dst = imlib_create_cropped_scaled_image((int)sz.sx, (int)sz.sy, (int)sz.sw, (int)sz.sh, (int)sz.dw, (int)sz.dh);
imlib_context_set_image(image_org);
imlib_free_image();
} else {
image_dst = image_org;
}
if (image_dst == NULL) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"imlib_create_cropped_scaled_image failed. %s:%d",
__FUNCTION__,
__LINE__);
return NGX_ERROR;
}
/* create canvas then draw image to the canvas. */
if (sz.cw > 0.0 && sz.ch > 0.0) {
image_tmp = imlib_create_image(sz.cw, sz.ch);
if (image_tmp == NULL) {
imlib_context_set_image(image_dst);
imlib_free_image();
return NGX_ERROR;
}
imlib_context_set_image(image_tmp);
imlib_context_set_color(sz.cc.r, sz.cc.g, sz.cc.b, sz.cc.a);
imlib_image_fill_rectangle(0, 0, sz.cw, sz.ch);
imlib_blend_image_onto_image(image_dst, 255, 0, 0,
(int)sz.dw, (int)sz.dh, (int)sz.dx, (int)sz.dy, (int)sz.dw, (int)sz.dh);
imlib_context_set_image(image_dst);
imlib_free_image();
image_dst = image_tmp;
}
/* effects. */
sharpen = NGX_HTTP_SMALL_LIGHT_PARAM_GET_LIT(&ctx->hash, "sharpen");
if (sharpen) {
radius = ngx_http_small_light_parse_int(sharpen);
if (radius > 0) {
imlib_context_set_image(image_dst);
imlib_image_sharpen(radius);
}
}
blur = NGX_HTTP_SMALL_LIGHT_PARAM_GET_LIT(&ctx->hash, "blur");
if (blur) {
radius = ngx_http_small_light_parse_int(blur);
if (radius > 0) {
imlib_context_set_image(image_dst);
imlib_image_blur(radius);
}
}
/* border. */
if (sz.bw > 0.0 || sz.bh > 0.0) {
imlib_context_set_color(sz.bc.r, sz.bc.g, sz.bc.b, sz.bc.a);
imlib_context_set_image(image_dst);
if (sz.cw > 0.0 && sz.ch > 0.0) {
imlib_image_fill_rectangle(0, 0, sz.cw, sz.bh);
imlib_image_fill_rectangle(0, 0, sz.bw, sz.ch);
imlib_image_fill_rectangle(0, sz.ch - sz.bh, sz.cw, sz.bh);
imlib_image_fill_rectangle(sz.cw - sz.bw, 0, sz.bw, sz.ch);
} else {
imlib_image_fill_rectangle(0, 0, sz.dw, sz.bh);
imlib_image_fill_rectangle(0, 0, sz.bw, sz.ch);
imlib_image_fill_rectangle(0, sz.dh - sz.bh, sz.dw, sz.bh);
imlib_image_fill_rectangle(sz.dw - sz.bw, 0, sz.bw, sz.dh);
}
}
/* set params. */
imlib_context_set_image(image_dst);
q = ngx_http_small_light_parse_double(NGX_HTTP_SMALL_LIGHT_PARAM_GET_LIT(&ctx->hash, "q"));
if (q > 0.0) {
imlib_image_attach_data_value("quality", NULL, q, NULL);
}
of = NGX_HTTP_SMALL_LIGHT_PARAM_GET_LIT(&ctx->hash, "of");
if (ngx_strlen(of) > 0) {
type = ngx_http_small_light_type(of);
if (type == NGX_HTTP_SMALL_LIGHT_IMAGE_NONE) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"of is invalid(%s) %s:%d",
of,
__FUNCTION__,
__LINE__);
of = (char *)ngx_http_small_light_image_exts[ictx->type - 1];
} else if (type == NGX_HTTP_SMALL_LIGHT_IMAGE_WEBP) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"WebP is not supported %s:%d",
__FUNCTION__,
__LINE__);
of = (char *)ngx_http_small_light_image_exts[ictx->type - 1];
} else {
ictx->type = type;
}
imlib_image_set_format(of);
ctx->of = ngx_http_small_light_image_types[ictx->type - 1];
} else {
ext = ngx_http_small_light_image_exts[ictx->type - 1];
imlib_image_set_format(ext);
ctx->of = ctx->inf;
}
/* save image. */
imlib_save_image_with_error_return(filename, &err);
imlib_free_image();
/* check error. */
if (err != IMLIB_LOAD_ERROR_NONE) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"failed to imlib_save_error %s:%d",
__FUNCTION__,
__LINE__);
return NGX_ERROR;
}
if (ngx_file_info(filename, &fi) == NGX_FILE_ERROR) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"failed to ngx_file_info %s:%d",
__FUNCTION__,
__LINE__);
return NGX_ERROR;
}
fd = ngx_open_file(filename, NGX_FILE_RDONLY, NGX_FILE_OPEN, 0);
if (fd == NGX_INVALID_FILE) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"failed to open fd %s:%d",
__FUNCTION__,
__LINE__);
return NGX_ERROR;
}
if (ngx_fd_info(fd, &fi) == NGX_FILE_ERROR) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"failed to ngx_fd_info %s:%d",
__FUNCTION__,
__LINE__);
ngx_close_file(fd);
return NGX_ERROR;
}
buf = ngx_palloc(r->pool, ngx_file_size(&fi));
if (buf == NULL) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"failed to allocate memory from r->pool %s:%d",
__FUNCTION__,
__LINE__);
ngx_close_file(fd);
return NGX_ERROR;
}
size = ngx_read_fd(fd, buf, ngx_file_size(&fi));
if (size == -1) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"failed to ngx_read_fd %s:%d",
__FUNCTION__,
__LINE__);
ngx_close_file(fd);
return NGX_ERROR;
}
if ((size_t)size > ctx->content_length) {
ctx->content = ngx_palloc(r->pool, size);
if (ctx->content == NULL) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"failed to allocate memory from r->pool %s:%d",
__FUNCTION__,
__LINE__);
ngx_close_file(fd);
return NGX_ERROR;
}
}
ngx_memcpy(ctx->content, buf, size);
ngx_close_file(fd);
ctx->content_length = size;
return NGX_OK;
}
int
main(int argc, char **argv)
{
int w, h;
Imlib_Image im_bg = NULL;
XEvent ev;
KeySym keysym;
static char kbuf[20];
ImlibPolygon poly, poly1, poly2;
const char *display_name = getenv("DISPLAY");
/**
* First tests to determine which rendering task to perform
*/
if (display_name == NULL)
display_name = ":0";
disp = XOpenDisplay(display_name);
if (disp == NULL)
{
fprintf(stderr, "Can't open display %s\n", display_name);
return 1;
}
vis = DefaultVisual(disp, DefaultScreen(disp));
depth = DefaultDepth(disp, DefaultScreen(disp));
cm = DefaultColormap(disp, DefaultScreen(disp));
win =
XCreateSimpleWindow(disp, DefaultRootWindow(disp), 0, 0, 100, 100, 0, 0,
0);
XSelectInput(disp, win,
ButtonPressMask | ButtonReleaseMask | ButtonMotionMask |
PointerMotionMask | ExposureMask | KeyPressMask);
XMapWindow(disp, win);
/**
* Start rendering
*/
imlib_context_set_display(disp);
imlib_context_set_visual(vis);
imlib_context_set_colormap(cm);
imlib_context_set_drawable(win);
imlib_context_set_blend(0);
imlib_context_set_color_modifier(NULL);
imlib_context_set_blend(0);
im_bg = imlib_create_image(400, 400);
imlib_context_set_image(im_bg);
w = imlib_image_get_width();
h = imlib_image_get_height();
imlib_context_set_color(0, 0, 0, 255);
imlib_image_fill_rectangle(0, 0, w, h);
XResizeWindow(disp, win, w, h);
XSync(disp, False);
poly = imlib_polygon_new();
imlib_polygon_add_point(poly, 20, 20);
imlib_polygon_add_point(poly, 70, 20);
imlib_polygon_add_point(poly, 70, 70);
imlib_polygon_add_point(poly, 20, 70);
poly1 = imlib_polygon_new();
imlib_polygon_add_point(poly1, 100, 20);
imlib_polygon_add_point(poly1, 190, 100);
imlib_polygon_add_point(poly1, 120, 70);
poly2 = imlib_polygon_new();
imlib_polygon_add_point(poly2, 290, 20);
imlib_polygon_add_point(poly2, 200, 100);
imlib_polygon_add_point(poly2, 270, 70);
while (1)
{
do
{
XNextEvent(disp, &ev);
switch (ev.type)
{
case ButtonRelease:
exit(0);
break;
case KeyPress:
XLookupString(&ev.xkey, (char *)kbuf, sizeof(kbuf), &keysym,
NULL);
switch (*kbuf)
{
case ' ':
imlib_context_set_anti_alias
(!imlib_context_get_anti_alias());
printf("AA is %s\n",
imlib_context_get_anti_alias()? "on" : "off");
break;
case 'q':
exit(0);
default:
break;
}
break;
default:
break;
}
}
while (XPending(disp));
imlib_context_set_image(im_bg);
imlib_context_set_color(0, 0, 0, 255);
imlib_image_fill_rectangle(0, 0, w, h);
imlib_context_set_color(255, 255, 255, 255);
imlib_image_fill_polygon(poly);
imlib_image_fill_polygon(poly1);
imlib_image_fill_polygon(poly2);
imlib_render_image_on_drawable(0, 0);
}
return 0;
}
int main (int argc, char **argv)
{
Visual *vis;
Colormap cm;
Display *_display;
Imlib_Context context;
Imlib_Image image;
Pixmap pixmap;
Imlib_Color_Modifier modifier = NULL;
_display = XOpenDisplay (NULL);
int width, height, depth, i, alpha;
char str1[40];
char str2[40];
char str3[40];
char str4[40];
char str5[40];
int ck0;
int w, h;
w = 0;
h = 0;
char strA1[30] = "hwe";
char strA2[30] = "hwer";
const char jpg[15] = "jpg"; //1
const char png[15] = "png"; //2
char *A1;
char *A2;
strcpy(strA1, argv[argc-1]);
strcpy(strA2, strA1);
A1 = strstr(strA1, jpg);
A2 = strstr(strA2, png);
//check to be sure image format is written right or abort
checkForNull(A1, A2);
for (screen = 0; screen < ScreenCount (_display); screen++)
{
display = XOpenDisplay (NULL);
context = imlib_context_new ();
imlib_context_push (context);
imlib_context_set_display (display);
vis = DefaultVisual (display, screen);
cm = DefaultColormap (display, screen);
width = DisplayWidth (display, screen);
height = DisplayHeight (display, screen);
depth = DefaultDepth (display, screen);
pixmap =
XCreatePixmap (display, RootWindow (display, screen),
width, height, depth);
imlib_context_set_visual (vis);
imlib_context_set_colormap (cm);
imlib_context_set_drawable (pixmap);
imlib_context_set_color_range (imlib_create_color_range ());
image = imlib_create_image (width, height);
imlib_context_set_image (image);
printf("1\n");
imlib_context_set_color (0, 0, 0, 255);
imlib_image_fill_rectangle (0, 0, width, height);
imlib_context_set_dither (1);
imlib_context_set_blend (1);
printf("2\n");
alpha = 255;
for (i = 1; i < argc; i++)
{
if (modifier != NULL)
{
imlib_apply_color_modifier ();
imlib_free_color_modifier ();
}
modifier = imlib_create_color_modifier ();
imlib_context_set_color_modifier (modifier);
if (strcmp (argv[i], "-alpha") == 0)
{
if ((++i) >= argc)
{
fprintf (stderr, "Missing alpha\n");
continue;
}
if (sscanf (argv[i], "%i", &alpha) == 0)
{
fprintf (stderr, "Bad alpha (%s)\n", argv[i]);
continue;
}
}
else if (strcmp (argv[i], "-solid") == 0)
{
Color c;
if ((++i) >= argc)
{
fprintf (stderr, "Missing color\n");
continue;
}
if (parse_color (argv[i], &c, alpha) == 1)
{
fprintf (stderr, "Bad color (%s)\n", argv[i]);
continue;
}
imlib_context_set_color (c.r, c.g, c.b, c.a);
imlib_image_fill_rectangle (0, 0, width, height);
}
else if (strcmp (argv[i], "-clear") == 0)
{
imlib_free_color_range ();
imlib_context_set_color_range (imlib_create_color_range ());
}
else if (strcmp (argv[i], "-add") == 0)
{
Color c;
if ((++i) >= argc)
{
fprintf (stderr, "Missing color\n");
continue;
}
if (parse_color (argv[i], &c, alpha) == 1)
{
fprintf (stderr, "Bad color (%s)\n", argv[i - 1]);
continue;
}
imlib_context_set_color (c.r, c.g, c.b, c.a);
imlib_add_color_to_color_range (1);
}
else if (strcmp (argv[i], "-addd") == 0)
{
Color c;
int distance;
if ((++i) >= argc)
{
fprintf (stderr, "Missing color\n");
continue;
}
if ((++i) >= argc)
{
fprintf (stderr, "Missing distance\n");
continue;
}
if (parse_color (argv[i - 1], &c, alpha) == 1)
{
fprintf (stderr, "Bad color (%s)\n", argv[i - 1]);
continue;
}
if (sscanf (argv[i], "%i", &distance) == 1)
{
fprintf (stderr, "Bad distance (%s)\n", argv[i]);
continue;
}
imlib_context_set_color (c.r, c.g, c.b, c.a);
imlib_add_color_to_color_range (distance);
}
else if (strcmp (argv[i], "-gradient") == 0)
{
int angle;
if ((++i) >= argc)
{
fprintf (stderr, "Missing angle\n");
continue;
}
if (sscanf (argv[i], "%i", &angle) == 1)
{
fprintf (stderr, "Bad angle (%s)\n", argv[i]);
continue;
}
imlib_image_fill_color_range_rectangle (0, 0, width, height,
angle);
}
else if (strcmp (argv[i], "-fill") == 0)
{
if ((++i) >= argc)
{
fprintf (stderr, "Missing image\n");
continue;
}
if ( load_Mod_image(Fill, argv[i], width, height, alpha, image, ck0) == 1)
{
fprintf (stderr, "Bad image (%s)\n", argv[i]);
continue;
}
}
else if (strcmp (argv[i], "-dia") == 0)
{
if((++i) >= argc)
{
fprintf(stderr, "missing Dia, and Image\n");
continue;
}
strcpy (str1, argv[i]);
strcpy (str2, str1);
if ( findX(str1, &w, &h) == 1 )
{
fprintf(stderr, " Bad Format\n");
continue;
}
else if (findX(str2, &w, &h) == 0 && ((++i) >= argc))
{
fprintf(stderr, "Missing Image\n");
continue;
}
else
{
//if format is correct then assign a number for
//load_Mod_Image to check
ck0 = -2;
w = w;
h = h;
}
if( load_Mod_image(Dia, argv[i], w, h, alpha, image, ck0) == 1 )
{
fprintf(stderr, "Bad Image or Bad Image Dimensions \n");
}
}
else if (strcmp (argv[i], "-tile") == 0)
{
if ((++i) >= argc)
{
fprintf(stderr, "format 0 missing \n");
continue;
}
strcpy (str1, argv[i]);
strcpy (str2, str1);
strcpy (str3, str2);
strcpy (str4, str3);
strcpy (str5, str4);
if ( findX(str1, &w, &h) == 3 && ((++i) >= argc))
{
fprintf(stderr, "missing Image\n");
continue;
} //check to see if format is -tile 0
else if (findX(str2, &w, &h) == 3)
{
ck0 = 3;
if( load_Mod_image(Tile, argv[i], width, height, alpha, image, ck0) == 1 )
{
fprintf(stderr, "Bad Image or Bad Image Dimensions \n");
continue;
}
}
if (findX(str3, &w, &h) == 1)
{
fprintf(stderr, "bad format\n");
continue;
}
if (findX(str4, &w, &h) == 0 && ((++i) >= argc))
{
fprintf(stderr, "missing something again\n");
continue;
}
if (findX (str5, &w, &h) == 0 )
{
ck0 = 2;
w = w;
h = h;
}
if( load_Mod_image(Tile, argv[i], w, h, alpha, image, ck0) == 1 )
{
fprintf(stderr, "Bad Image or Bad Image Dimension\n");
}
}
else if (strcmp (argv[i], "-center") == 0)
{
if ((++i) >= argc)
{
fprintf (stderr, "Missing image\n");
continue;
}
if (load_Mod_image (Center, argv[i], width, height, alpha, image, ck0) == 1)
{
fprintf (stderr, "Bad image (%s)\n", argv[i]);
continue;
}
}
else if (strcmp (argv[i], "-tint") == 0)
{
Color c;
DATA8 r[256], g[256], b[256], a[256];
int j;
if ((++i) >= argc)
{
fprintf (stderr, "Missing color\n");
continue;
}
if (parse_color (argv[i], &c, 255) == 1)
{
fprintf (stderr, "Bad color\n");
continue;
}
imlib_get_color_modifier_tables (r, g, b, a);
for (j = 0; j < 256; j++)
{
r[j] = (DATA8) (((double) r[j] / 255.0) * (double) c.r);
g[j] = (DATA8) (((double) g[j] / 255.0) * (double) c.g);
b[j] = (DATA8) (((double) b[j] / 255.0) * (double) c.b);
}
imlib_set_color_modifier_tables (r, g, b, a);
}
else if (strcmp (argv[i], "-blur") == 0)
{
int intval;
if ((++i) >= argc)
{
fprintf (stderr, "Missing value\n");
continue;
}
if (sscanf (argv[i], "%i", &intval) == 1)
{
fprintf (stderr, "Bad value (%s)\n", argv[i]);
continue;
}
imlib_image_blur (intval);
}
else if (strcmp (argv[i], "-sharpen") == 0)
{
int intval;
if ((++i) >= argc)
{
fprintf (stderr, "Missing value\n");
continue;
}
if (sscanf (argv[i], "%i", &intval) == 1)
{
fprintf (stderr, "Bad value (%s)\n", argv[i]);
continue;
}
imlib_image_sharpen (intval);
}
else if (strcmp (argv[i], "-contrast") == 0)
{
double dblval;
if ((++i) >= argc)
{
fprintf (stderr, "Missing value\n");
continue;
}
if (sscanf (argv[i], "%lf", &dblval) == 1)
{
fprintf (stderr, "Bad value (%s)\n", argv[i]);
continue;
}
imlib_modify_color_modifier_contrast (dblval);
}
else if (strcmp (argv[i], "-brightness") == 0)
{
double dblval;
if ((++i) >= argc)
{
fprintf (stderr, "Missing value\n");
continue;
}
if (sscanf (argv[i], "%lf", &dblval) == 1)
{
fprintf (stderr, "Bad value (%s)\n", argv[i]);
continue;
}
imlib_modify_color_modifier_brightness (dblval);
}
else if (strcmp (argv[i], "-gamma") == 0)
{
double dblval;
if ((++i) >= argc)
{
fprintf (stderr, "Missing value\n");
continue;
}
if (sscanf (argv[i], "%lf", &dblval) == 1)
{
fprintf (stderr, "Bad value (%s)\n", argv[i]);
continue;
}
imlib_modify_color_modifier_gamma (dblval);
}
else if (strcmp (argv[i], "-flipv") == 0)
{
imlib_image_flip_vertical ();
}
else if (strcmp (argv[i], "-fliph") == 0)
{
imlib_image_flip_horizontal ();
}
else if (strcmp (argv[i], "-flipd") == 0)
{
imlib_image_flip_diagonal ();
}
else if (strcmp (argv[i], "-write") == 0)
{
if ((++i) >= argc)
{
fprintf (stderr, "Missing filename\n");
continue;
}
imlib_save_image (argv[i]);
}
else
{
usage (argv[0]);
imlib_free_image ();
imlib_free_color_range ();
if (modifier != NULL)
{
imlib_context_set_color_modifier (modifier);
imlib_free_color_modifier ();
modifier = NULL;
}
XFreePixmap (display, pixmap);
exit (1);
} // end else
} // end loop off of argc
if (modifier != NULL)
{
imlib_context_set_color_modifier (modifier);
imlib_apply_color_modifier ();
imlib_free_color_modifier ();
modifier = NULL;
}
imlib_render_image_on_drawable (0, 0);
imlib_free_image ();
imlib_free_color_range ();
if (setRootAtoms (pixmap) == 0)
fprintf (stderr, "Couldn't create atoms...\n");
XKillClient (display, AllTemporary);
XSetCloseDownMode (display, RetainTemporary);
XSetWindowBackgroundPixmap (display, RootWindow (display, screen),
pixmap);
XClearWindow (display, RootWindow (display, screen));
XFlush (display);
XSync (display, False);
imlib_context_pop ();
imlib_context_free (context);
} // end for loop off screen
// } // frist if statment at start of main
return 0;
}
void Color::use() {
imlib_context_set_color(r,g,b,a);
}
int
main(int argc, char **argv)
{
int w, h, tw, th;
Imlib_Image im_bg = NULL;
XEvent ev;
KeySym keysym;
static char kbuf[20];
Imlib_Font font;
Imlib_Color_Range range;
const char *display_name = getenv("DISPLAY");
/**
* First tests to determine which rendering task to perform
*/
if (display_name == NULL)
display_name = ":0";
disp = XOpenDisplay(display_name);
if (disp == NULL)
{
fprintf(stderr, "Can't open display %s\n", display_name);
return 1;
}
vis = DefaultVisual(disp, DefaultScreen(disp));
depth = DefaultDepth(disp, DefaultScreen(disp));
cm = DefaultColormap(disp, DefaultScreen(disp));
win =
XCreateSimpleWindow(disp, DefaultRootWindow(disp), 0, 0, 100, 100, 0, 0,
0);
XSelectInput(disp, win,
ButtonPressMask | ButtonReleaseMask | ButtonMotionMask |
PointerMotionMask | ExposureMask | KeyPressMask);
XMapWindow(disp, win);
/**
* Start rendering
*/
imlib_set_font_cache_size(512 * 1024);
imlib_add_path_to_font_path(PACKAGE_DATA_DIR"/data/fonts");
imlib_context_set_display(disp);
imlib_context_set_visual(vis);
imlib_context_set_colormap(cm);
imlib_context_set_drawable(win);
imlib_context_set_blend(0);
imlib_context_set_color_modifier(NULL);
imlib_context_set_blend(0);
im_bg = imlib_create_image(600, 400);
imlib_context_set_image(im_bg);
w = imlib_image_get_width();
h = imlib_image_get_height();
imlib_context_set_color(128, 128, 255, 255);
imlib_image_fill_rectangle(0, 0, w, h);
XResizeWindow(disp, win, w, h);
XSync(disp, False);
while (1)
{
do
{
XNextEvent(disp, &ev);
switch (ev.type)
{
case ButtonRelease:
exit(0);
break;
case KeyPress:
XLookupString(&ev.xkey, (char *)kbuf, sizeof(kbuf), &keysym,
NULL);
switch (*kbuf)
{
case 'q':
exit(0);
default:
break;
}
break;
default:
break;
}
}
while (XPending(disp));
imlib_context_set_image(im_bg);
imlib_context_set_color(128, 128, 255, 255);
imlib_image_fill_rectangle(0, 0, w, h);
imlib_context_set_color(0, 0, 0, 255);
imlib_image_draw_rectangle(20, 20, 560, 140);
imlib_image_draw_rectangle(20, 220, 560, 140);
font = imlib_load_font("notepad/15");
if (font)
{
char text[4096];
imlib_context_set_font(font);
imlib_context_set_color(0, 0, 0, 255);
sprintf(text, "RGBA range, 2 points, from red to magenta");
imlib_get_text_size(text, &tw, &th);
imlib_text_draw(300 - tw / 2, 180 - th / 2, text);
sprintf(text, "HSVA range, 2 points, from red to magenta");
imlib_get_text_size(text, &tw, &th);
imlib_text_draw(300 - tw / 2, 380 - th / 2, text);
imlib_free_font();
}
/* Draw rectangle w/ RGBA gradient */
range = imlib_create_color_range();
imlib_context_set_color_range(range);
imlib_context_set_color(255, 0, 0, 255);
imlib_add_color_to_color_range(0);
imlib_context_set_color(255, 0, 255, 255);
imlib_add_color_to_color_range(20);
imlib_image_fill_color_range_rectangle(21, 21, 558, 138, -90.0);
imlib_free_color_range();
/* Draw rectangle w/ HSVA gradient */
range = imlib_create_color_range();
imlib_context_set_color_range(range);
imlib_context_set_color_hsva(0, 1, 1, 255);
imlib_add_color_to_color_range(0);
imlib_context_set_color_hsva(300, 1, 1, 255);
imlib_add_color_to_color_range(20);
imlib_image_fill_hsva_color_range_rectangle(21, 221, 558, 138, -90.0);
imlib_free_color_range();
imlib_render_image_on_drawable(0, 0);
}
return 0;
}
static int
progress(Imlib_Image im, char percent, int update_x, int update_y,
int update_w, int update_h)
{
/* first time it's called */
imlib_context_set_drawable(pm);
imlib_context_set_anti_alias(0);
imlib_context_set_dither(0);
imlib_context_set_blend(0);
if (image_width == 0)
{
int x, y, onoff;
imlib_context_set_image(im);
image_width = imlib_image_get_width();
image_height = imlib_image_get_height();
if (pm)
XFreePixmap(disp, pm);
pm = XCreatePixmap(disp, win, image_width, image_height, depth);
imlib_context_set_drawable(pm);
if (bg_im)
{
imlib_context_set_image(bg_im);
imlib_free_image_and_decache();
}
bg_im = imlib_create_image(image_width, image_height);
imlib_context_set_image(bg_im);
for (y = 0; y < image_height; y += 8)
{
onoff = (y / 8) & 0x1;
for (x = 0; x < image_width; x += 8)
{
if (onoff)
imlib_context_set_color(144, 144, 144, 255);
else
imlib_context_set_color(100, 100, 100, 255);
imlib_image_fill_rectangle(x, y, 8, 8);
onoff++;
if (onoff == 2)
onoff = 0;
}
}
imlib_render_image_part_on_drawable_at_size(0, 0, image_width,
image_height, 0, 0,
image_width, image_height);
XSetWindowBackgroundPixmap(disp, win, pm);
XResizeWindow(disp, win, image_width, image_height);
XMapWindow(disp, win);
XSync(disp, False);
}
imlib_context_set_anti_alias(0);
imlib_context_set_dither(0);
imlib_context_set_blend(1);
imlib_blend_image_onto_image(im, 0,
update_x, update_y,
update_w, update_h,
update_x, update_y, update_w, update_h);
imlib_context_set_blend(0);
imlib_render_image_part_on_drawable_at_size(update_x, update_y,
update_w, update_h,
update_x, update_y,
update_w, update_h);
XSetWindowBackgroundPixmap(disp, win, pm);
XClearArea(disp, win, update_x, update_y, update_w, update_h, False);
XFlush(disp);
return 1;
}
int Configure(void **ctxp, int argc, char *argv[])
{
int c;
ContextInfo *ci;
char *font = "LucidaSansDemiBold/16";
char *fp = getenv("FONTPATH");
char *color = 0;
FILE *f;
*ctxp = av_mallocz(sizeof(ContextInfo));
ci = (ContextInfo *) *ctxp;
optind = 0;
if (fp)
imlib_add_path_to_font_path(fp);
while ((c = getopt(argc, argv, "c:f:F:t:x:y:")) > 0) {
switch (c) {
case 'c':
color = optarg;
break;
case 'F':
font = optarg;
break;
case 't':
ci->text = av_strdup(optarg);
break;
case 'f':
ci->file = av_strdup(optarg);
break;
case 'x':
ci->x = atoi(optarg);
break;
case 'y':
ci->y = atoi(optarg);
break;
case '?':
fprintf(stderr, "Unrecognized argument '%s'\n", argv[optind]);
return -1;
}
}
ci->fn = imlib_load_font(font);
if (!ci->fn) {
fprintf(stderr, "Failed to load font '%s'\n", font);
return -1;
}
imlib_context_set_font(ci->fn);
imlib_context_set_direction(IMLIB_TEXT_TO_RIGHT);
if (color) {
char buff[256];
int done = 0;
f = fopen("/usr/lib/X11/rgb.txt", "r");
if (!f) {
fprintf(stderr, "Failed to find rgb.txt\n");
return -1;
}
while (fgets(buff, sizeof(buff), f)) {
int r, g, b;
char colname[80];
if (sscanf(buff, "%d %d %d %64s", &r, &g, &b, colname) == 4 &&
strcasecmp(colname, color) == 0) {
ci->r = r;
ci->g = g;
ci->b = b;
/* fprintf(stderr, "%s -> %d,%d,%d\n", colname, r, g, b); */
done = 1;
break;
}
}
fclose(f);
if (!done) {
fprintf(stderr, "Unable to find color '%s' in rgb.txt\n", color);
return -1;
}
}
imlib_context_set_color(ci->r, ci->g, ci->b, 255);
return 0;
}
