void feh_draw_errstr(winwidget w)
{
static Imlib_Font fn = NULL;
int tw = 0, th = 0;
Imlib_Image im = NULL;
if (!w->im)
return;
fn = feh_load_font(NULL);
/* Work out how high the font is */
gib_imlib_get_text_size(fn, w->errstr, NULL, &tw, &th, IMLIB_TEXT_TO_RIGHT);
tw += 3;
th += 3;
im = imlib_create_image(tw, th);
if (!im)
eprintf("Couldn't create errstr image. Out of memory?");
feh_imlib_image_fill_text_bg(im, tw, th);
gib_imlib_text_draw(im, fn, NULL, 2, 2, w->errstr, IMLIB_TEXT_TO_RIGHT, 0, 0, 0, 255);
gib_imlib_text_draw(im, fn, NULL, 1, 1, w->errstr, IMLIB_TEXT_TO_RIGHT, 255, 0, 0, 255);
free(w->errstr);
w->errstr = NULL;
gib_imlib_render_image_on_drawable(w->bg_pmap, im, 0, w->h - th, 1, 1, 0);
gib_imlib_free_image_and_decache(im);
}
void feh_draw_zoom(winwidget w)
{
static Imlib_Font fn = NULL;
int tw = 0, th = 0;
Imlib_Image im = NULL;
char buf[100];
if (!w->im)
return;
fn = feh_load_font(w);
snprintf(buf, sizeof(buf), "%.0f%%, %dx%d", w->zoom * 100,
(int) (w->im_w * w->zoom), (int) (w->im_h * w->zoom));
/* Work out how high the font is */
gib_imlib_get_text_size(fn, buf, NULL, &tw, &th, IMLIB_TEXT_TO_RIGHT);
tw += 3;
th += 3;
im = imlib_create_image(tw, th);
if (!im)
eprintf("Couldn't create image. Out of memory?");
feh_imlib_image_fill_text_bg(im, tw, th);
gib_imlib_text_draw(im, fn, NULL, 2, 2, buf, IMLIB_TEXT_TO_RIGHT, 0, 0, 0, 255);
gib_imlib_text_draw(im, fn, NULL, 1, 1, buf, IMLIB_TEXT_TO_RIGHT, 255, 255, 255, 255);
gib_imlib_render_image_on_drawable(w->bg_pmap, im, 0, w->h - th, 1, 1, 0);
gib_imlib_free_image_and_decache(im);
return;
}
void saveImage(image * img, const char *filename)
{
Imlib_Image out;
int i, j;
out = imlib_create_image(img->width, img->height);
imlib_context_set_image(out);
for (i = 0; i < img->width; i++) {
for (j = 0; j < img->height; j++) {
int red = (int) img->red->vals[i][j];
int green = (int) img->green->vals[i][j];
int blue = (int) img->blue->vals[i][j];
red = red <= 255 ? red : 255;
green = green <= 255 ? green : 255;
blue = blue <= 255 ? blue : 255;
imlib_context_set_color(red, green, blue, 255);
imlib_image_draw_line(i, j, i, j, 0);
}
}
imlib_save_image(filename);
imlib_free_image();
}
void render_text(char * text, int button_x, int button_y, int * button_w, int * button_h) {
Imlib_Image buffer;
int text_w, text_h;
/* query the size it will be */
imlib_get_text_size(text, &text_w, &text_h);
*button_w = text_w + pad_width;
*button_h = text_height + pad_height;
/* create our buffer image for rendering this update */
buffer = imlib_create_image(*button_w, *button_h);
if ( buffer == NULL ) {
fprintf(stderr, "Null buffer First\n");
return;
}
imlib_context_set_image(buffer);
imlib_context_set_color(tag_color.red,tag_color.green,tag_color.blue,tag_color.alpha);
imlib_image_fill_rectangle(0,0, *button_w, *button_h);
imlib_context_set_color(255, 255, 255, 255);
imlib_text_draw(pad_width/2, pad_height/2, text);
imlib_render_image_on_drawable(button_x, button_y);
imlib_free_image();
}
void init_render(struct xinfo *X, struct panel *P)
{
bbwidth = P->width;
bbheight = P->theme->height;
bb = imlib_create_image(bbwidth, bbheight);
bbcolor = imlib_create_image(bbwidth, bbheight);
imlib_context_set_image(bb);
imlib_image_set_has_alpha(1);
bbdpy = X->display;
bbvis = X->visual;
bbwin = P->win;
bbcm = X->colmap;
bbx = P->x;
bby = P->y;
rootpmap = &X->rootpmap;
theme = P->theme;
imlib_context_set_display(bbdpy);
imlib_context_set_visual(bbvis);
imlib_context_set_colormap(bbcm);
#ifdef WITH_COMPOSITE
if (P->theme->use_composite) {
XRenderPictFormat *fmt = XRenderFindStandardFormat(bbdpy, PictStandardARGB32);
bbalpha = imlib_create_image(bbwidth, bbheight);
pixcolor = XCreatePixmap(bbdpy, bbwin, bbwidth, bbheight, 32);
pixalpha = XCreatePixmap(bbdpy, bbwin, bbwidth, bbheight, 32);
piccolor = XRenderCreatePicture(bbdpy, pixcolor, fmt, 0, 0);
picalpha = XRenderCreatePicture(bbdpy, pixalpha, fmt, 0, 0);
XRenderPictureAttributes pwin;
pwin.subwindow_mode = IncludeInferiors;
rootpic = XRenderCreatePicture(bbdpy, bbwin, XRenderFindVisualFormat(bbdpy, bbvis),
CPSubwindowMode, &pwin);
} else
#endif
if (*rootpmap) {
update_bg();
} else {
set_bg();
}
imlib_context_set_blend(0);
imlib_context_set_operation(IMLIB_OP_COPY);
}
void feh_draw_filename(winwidget w)
{
static Imlib_Font fn = NULL;
int tw = 0, th = 0, nw = 0;
Imlib_Image im = NULL;
char *s = NULL;
int len = 0;
if ((!w->file) || (!FEH_FILE(w->file->data))
|| (!FEH_FILE(w->file->data)->filename))
return;
fn = feh_load_font(w);
/* Work out how high the font is */
gib_imlib_get_text_size(fn, FEH_FILE(w->file->data)->filename, NULL, &tw,
&th, IMLIB_TEXT_TO_RIGHT);
if (gib_list_length(filelist) > 1) {
len = snprintf(NULL, 0, "%d of %d", gib_list_length(filelist),
gib_list_length(filelist)) + 1;
s = emalloc(len);
if (w->file)
snprintf(s, len, "%d of %d", gib_list_num(filelist, w->file) +
1, gib_list_length(filelist));
else
snprintf(s, len, "%d of %d", gib_list_num(filelist, current_file) +
1, gib_list_length(filelist));
gib_imlib_get_text_size(fn, s, NULL, &nw, NULL, IMLIB_TEXT_TO_RIGHT);
if (nw > tw)
tw = nw;
}
tw += 3;
th += 3;
im = imlib_create_image(tw, 2 * th);
if (!im)
eprintf("Couldn't create image. Out of memory?");
feh_imlib_image_fill_text_bg(im, tw, 2 * th);
gib_imlib_text_draw(im, fn, NULL, 2, 2, FEH_FILE(w->file->data)->filename,
IMLIB_TEXT_TO_RIGHT, 0, 0, 0, 255);
gib_imlib_text_draw(im, fn, NULL, 1, 1, FEH_FILE(w->file->data)->filename,
IMLIB_TEXT_TO_RIGHT, 255, 255, 255, 255);
if (s) {
gib_imlib_text_draw(im, fn, NULL, 2, th + 1, s, IMLIB_TEXT_TO_RIGHT, 0, 0, 0, 255);
gib_imlib_text_draw(im, fn, NULL, 1, th, s, IMLIB_TEXT_TO_RIGHT, 255, 255, 255, 255);
free(s);
}
gib_imlib_render_image_on_drawable(w->bg_pmap, im, 0, 0, 1, 1, 0);
gib_imlib_free_image_and_decache(im);
return;
}
void
mainwin_update_background(MainWin *mw)
{
Pixmap dummy = wm_get_root_pmap(mw->dpy);
Window dummy_root;
int x, y;
unsigned int root_w, root_h, border_width, depth;
XGetGeometry(mw->dpy, mw->root, &dummy_root, &x, &y, &root_w, &root_h, &border_width, &depth);
if(mw->background != 0)
{
imlib_context_set_image(mw->background);
imlib_free_image();
}
if(dummy != None)
{
unsigned int width, height;
mw->background = imlib_create_image(root_w, root_h);
imlib_context_set_image(mw->background);
XGetGeometry(mw->dpy, dummy, &dummy_root, &x, &y, &width, &height, &border_width, &depth);
imlib_context_set_drawable(dummy);
imlib_copy_drawable_to_image(0, 0, 0, width, height, 0, 0, 1);
for(x = 1; x < (int)ceil((double)root_w / width); ++x)
imlib_image_copy_rect(0, 0, width, height, x * width, 0);
for(y = 1; y < (int)ceil((double)root_h / height); ++y)
imlib_image_copy_rect(0, 0, root_w, height, 0, y * height);
}
else
{
mw->background = imlib_create_image(root_w, root_h);
imlib_context_set_image(mw->background);
imlib_image_clear();
}
mainwin_update_bg_pixmap(mw);
REDUCE(clientwin_render((ClientWin*)iter->data), mw->cod);
}
struct image *image_new(int width, int height)
{
struct image *img;
#if defined(HAVE_SDL_IMAGE_H)
SDL_Surface *priv;
Uint32 rmask, gmask, bmask, amask;
# if SDL_BYTEORDER == SDL_BIG_ENDIAN
rmask = 0xff000000;
gmask = 0x00ff0000;
bmask = 0x0000ff00;
amask = 0x00000000;
# else
rmask = 0x000000ff;
gmask = 0x0000ff00;
bmask = 0x00ff0000;
amask = 0x00000000;
# endif
priv = SDL_CreateRGBSurface(SDL_SWSURFACE, width, height, 32,
rmask, gmask, bmask, amask);
#elif defined(HAVE_IMLIB2_H)
Imlib_Image priv = imlib_create_image(width, height);
#elif defined(HAVE_CV_H)
IplImage *priv = cvCreateImage(cvSize(width, height), IPL_DEPTH_8U, 3);
#endif
if(!priv)
return NULL;
img = (struct image *)malloc(sizeof(struct image));
#if defined(HAVE_SDL_IMAGE_H)
img->width = priv->w;
img->height = priv->h;
img->pitch = priv->pitch;
img->channels = priv->format->BytesPerPixel;
img->pixels = priv->pixels;
#elif defined(HAVE_IMLIB2_H)
imlib_context_set_image(priv);
img->width = imlib_image_get_width();
img->height = imlib_image_get_height();
img->pitch = 4 * imlib_image_get_width();
img->channels = 4;
img->pixels = (char *)imlib_image_get_data();
#elif defined(HAVE_CV_H)
img->width = priv->width;
img->height = priv->height;
img->pitch = priv->widthStep;
img->channels = priv->nChannels;
img->pixels = priv->imageData;
#endif
img->priv = (void *)priv;
return img;
}
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;
}
inline PyObject *
_pyimlib2_create_image(PyObject *self, PyObject *args)
{
int w, h;
if (!PyArg_ParseTuple(args, "ii:create_image", &w, &h)){
return NULL;
}
Imlib_Image image = imlib_create_image(w, h);
if(!image){
//TODO Error
return NULL;
}
return (PyObject *)ImageObject_New(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();
}
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();
}
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;
}
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 struct sequ_image *im2_resize(struct sequ_image *old,int w, int h)
{
if(old != NULL)
{
if(w == old->width && h == old->height)
return old;
imlib_context_set_image((Imlib_Image)old->privdata);
imlib_free_image_and_decache();
}
else
old=malloc(sizeof(sequ_image));
old->privdata=imlib_create_image(w,h);
old->lib=&im2_lib;
img_from_im2(old,(Imlib_Image)old->privdata);
return old;
}
Imlib_Image
stalk_image_concat(gib_list * images)
{
int tot_w = 0, max_h = 0, w, h;
int x = 0;
gib_list *l, *item;
Imlib_Image ret, im;
if (gib_list_length(images) == 0)
return NULL;
l = images;
while (l) {
im = (Imlib_Image) l->data;
h = gib_imlib_image_get_height(im);
w = gib_imlib_image_get_width(im);
if (h > max_h)
max_h = h;
tot_w += w;
l = l->next;
}
ret = imlib_create_image(tot_w, max_h);
gib_imlib_image_fill_rectangle(ret, 0, 0, tot_w, max_h, 255, 0, 0, 0);
l = images;
while (l) {
im = (Imlib_Image) l->data;
item = l;
l = l->next;
h = gib_imlib_image_get_height(im);
w = gib_imlib_image_get_width(im);
gib_imlib_blend_image_onto_image(ret, im, 0, 0, 0, w, h, x, 0, w, h, 1, 0,
0);
x += w;
gib_imlib_free_image_and_decache(im);
free(item);
}
return ret;
}
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;
}
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();
}
void feh_draw_info(winwidget w)
{
static Imlib_Font fn = NULL;
int width = 0, height = 0, line_width = 0, line_height = 0;
Imlib_Image im = NULL;
int no_lines = 0, i;
char *info_cmd;
char info_line[256];
char *info_buf[128];
FILE *info_pipe;
if ((!w->file) || (!FEH_FILE(w->file->data))
|| (!FEH_FILE(w->file->data)->filename))
return;
fn = feh_load_font(w);
info_cmd = feh_printf(opt.info_cmd, FEH_FILE(w->file->data), w);
info_pipe = popen(info_cmd, "r");
if (!info_pipe) {
info_buf[0] = estrdup("Failed to run info command");
gib_imlib_get_text_size(fn, info_buf[0], NULL, &width, &height, IMLIB_TEXT_TO_RIGHT);
no_lines = 1;
}
else {
while ((no_lines < 128) && fgets(info_line, 256, info_pipe)) {
if (info_line[strlen(info_line)-1] == '\n')
info_line[strlen(info_line)-1] = '\0';
gib_imlib_get_text_size(fn, info_line, NULL, &line_width,
&line_height, IMLIB_TEXT_TO_RIGHT);
if (line_height > height)
height = line_height;
if (line_width > width)
width = line_width;
info_buf[no_lines] = estrdup(info_line);
no_lines++;
}
pclose(info_pipe);
}
if (no_lines == 0)
return;
height *= no_lines;
width += 4;
im = imlib_create_image(width, height);
if (!im)
eprintf("Couldn't create image. Out of memory?");
feh_imlib_image_fill_text_bg(im, width, height);
for (i = 0; i < no_lines; i++) {
gib_imlib_text_draw(im, fn, NULL, 2, (i * line_height) + 2,
info_buf[i], IMLIB_TEXT_TO_RIGHT, 0, 0, 0, 255);
gib_imlib_text_draw(im, fn, NULL, 1, (i * line_height) + 1,
info_buf[i], IMLIB_TEXT_TO_RIGHT, 255, 255, 255, 255);
free(info_buf[i]);
}
gib_imlib_render_image_on_drawable(w->bg_pmap, im, 0,
w->h - height, 1, 1, 0);
gib_imlib_free_image_and_decache(im);
return;
}
void feh_draw_caption(winwidget w)
{
static Imlib_Font fn = NULL;
int tw = 0, th = 0, ww, hh;
int x, y;
Imlib_Image im = NULL;
char *p;
gib_list *lines, *l;
static gib_style *caption_style = NULL;
feh_file *file;
if (!w->file) {
return;
}
file = FEH_FILE(w->file->data);
if (!file->filename) {
return;
}
if (!file->caption) {
char *caption_filename;
caption_filename = build_caption_filename(file, 0);
if (caption_filename)
/* read caption from file */
file->caption = ereadfile(caption_filename);
else
file->caption = estrdup("");
free(caption_filename);
}
if (file->caption == NULL) {
/* caption file is not there, we want to cache that, otherwise we'll stat
* the damn file every time we render the image. Reloading an image will
* always cause the caption to be reread though so we're safe to do so.
* (Before this bit was added, when zooming a captionless image with
* captions enabled, the captions file would be stat()d like 30 times a
* second) - don't forget this function is called from
* winwidget_render_image().
*/
file->caption = estrdup("");
}
if (*(file->caption) == '\0' && !w->caption_entry)
return;
caption_style = gib_style_new("caption");
caption_style->bits = gib_list_add_front(caption_style->bits,
gib_style_bit_new(0, 0, 0, 0, 0, 0));
caption_style->bits = gib_list_add_front(caption_style->bits,
gib_style_bit_new(1, 1, 0, 0, 0, 255));
fn = feh_load_font(w);
if (*(file->caption) == '\0') {
p = estrdup("Caption entry mode - Hit ESC to cancel");
lines = feh_wrap_string(p, w->w, fn, NULL);
free(p);
} else
lines = feh_wrap_string(file->caption, w->w, fn, NULL);
if (!lines)
return;
/* Work out how high/wide the caption is */
l = lines;
while (l) {
p = (char *) l->data;
gib_imlib_get_text_size(fn, p, caption_style, &ww, &hh, IMLIB_TEXT_TO_RIGHT);
if (ww > tw)
tw = ww;
th += hh;
if (l->next)
th += 1; /* line spacing */
l = l->next;
}
/* we don't want the caption overlay larger than our window */
if (th > w->h)
th = w->h;
if (tw > w->w)
tw = w->w;
im = imlib_create_image(tw, th);
if (!im)
eprintf("Couldn't create image. Out of memory?");
feh_imlib_image_fill_text_bg(im, tw, th);
l = lines;
x = 0;
y = 0;
while (l) {
p = (char *) l->data;
gib_imlib_get_text_size(fn, p, caption_style, &ww, &hh, IMLIB_TEXT_TO_RIGHT);
x = (tw - ww) / 2;
if (w->caption_entry && (*(file->caption) == '\0'))
gib_imlib_text_draw(im, fn, caption_style, x, y, p,
IMLIB_TEXT_TO_RIGHT, 255, 255, 127, 255);
else if (w->caption_entry)
gib_imlib_text_draw(im, fn, caption_style, x, y, p,
IMLIB_TEXT_TO_RIGHT, 255, 255, 0, 255);
else
gib_imlib_text_draw(im, fn, caption_style, x, y, p,
IMLIB_TEXT_TO_RIGHT, 255, 255, 255, 255);
y += hh + 1; /* line spacing */
l = l->next;
}
gib_imlib_render_image_on_drawable(w->bg_pmap, im, (w->w - tw) / 2, w->h - th, 1, 1, 0);
gib_imlib_free_image_and_decache(im);
gib_list_free_and_data(lines);
return;
}
void feh_draw_exif(winwidget w)
{
static Imlib_Font fn = NULL;
int width = 0, height = 0, line_width = 0, line_height = 0;
Imlib_Image im = NULL;
int no_lines = 0, i;
int pos = 0;
int pos2 = 0;
char info_line[256];
char *info_buf[128];
char buffer[EXIF_MAX_DATA];
if ( (!w->file) || (!FEH_FILE(w->file->data))
|| (!FEH_FILE(w->file->data)->filename) )
{
return;
}
buffer[0] = '\0';
exif_get_info(FEH_FILE(w->file->data)->ed, buffer, EXIF_MAX_DATA);
fn = feh_load_font(w);
if (buffer == NULL)
{
snprintf(buffer, EXIF_MAX_DATA, "%s", estrdup("Failed to run exif command"));
gib_imlib_get_text_size(fn, &buffer[0], NULL, &width, &height, IMLIB_TEXT_TO_RIGHT);
no_lines = 1;
}
else
{
while ( (no_lines < 128) && (pos < EXIF_MAX_DATA) )
{
/* max 128 lines */
pos2 = 0;
while ( pos2 < 256 ) /* max 256 chars per line */
{
if ( (buffer[pos] != '\n')
&& (buffer[pos] != '\0') )
{
info_line[pos2] = buffer[pos];
}
else if ( buffer[pos] == '\0' )
{
pos = EXIF_MAX_DATA; /* all data seen */
info_line[pos2] = '\0';
}
else
{
info_line[pos2] = '\0'; /* line finished, continue with next line*/
pos++;
break;
}
pos++;
pos2++;
}
gib_imlib_get_text_size(fn, info_line, NULL, &line_width,
&line_height, IMLIB_TEXT_TO_RIGHT);
if (line_height > height)
height = line_height;
if (line_width > width)
width = line_width;
info_buf[no_lines] = estrdup(info_line);
no_lines++;
}
}
if (no_lines == 0)
return;
height *= no_lines;
width += 4;
im = imlib_create_image(width, height);
if (!im)
{
eprintf("Couldn't create image. Out of memory?");
}
feh_imlib_image_fill_text_bg(im, width, height);
for (i = 0; i < no_lines; i++)
{
gib_imlib_text_draw(im, fn, NULL, 2, (i * line_height) + 2,
info_buf[i], IMLIB_TEXT_TO_RIGHT, 0, 0, 0, 255);
gib_imlib_text_draw(im, fn, NULL, 1, (i * line_height) + 1,
info_buf[i], IMLIB_TEXT_TO_RIGHT, 255, 255, 255, 255);
}
gib_imlib_render_image_on_drawable(w->bg_pmap, im, 0, w->h - height, 1, 1, 0);
gib_imlib_free_image_and_decache(im);
return;
}
void Process(void *ctx, AVPicture *picture, enum PixelFormat pix_fmt, int width, int height, int64_t pts)
{
ContextInfo *ci = (ContextInfo *) ctx;
AVPicture picture1;
Imlib_Image image;
DATA32 *data;
image = get_cached_image(ci, width, height);
if (!image) {
image = imlib_create_image(width, height);
put_cached_image(ci, image, width, height);
}
imlib_context_set_image(image);
data = imlib_image_get_data();
if (pix_fmt != PIX_FMT_RGBA32) {
avpicture_fill(&picture1, (uint8_t *) data, PIX_FMT_RGBA32, width, height);
if (img_convert(&picture1, PIX_FMT_RGBA32,
picture, pix_fmt, width, height) < 0) {
goto done;
}
} else {
av_abort();
}
imlib_image_set_has_alpha(0);
{
int wid, hig, h_a, v_a;
char buff[1000];
char tbuff[1000];
char *tbp = ci->text;
time_t now = time(0);
char *p, *q;
int x, y;
if (ci->file) {
int fd = open(ci->file, O_RDONLY);
if (fd < 0) {
tbp = "[File not found]";
} else {
int l = read(fd, tbuff, sizeof(tbuff) - 1);
if (l >= 0) {
tbuff[l] = 0;
tbp = tbuff;
} else {
tbp = "[I/O Error]";
}
close(fd);
}
}
strftime(buff, sizeof(buff), tbp ? tbp : "[No data]", localtime(&now));
x = ci->x;
y = ci->y;
for (p = buff; p; p = q) {
q = strchr(p, '\n');
if (q)
*q++ = 0;
imlib_text_draw_with_return_metrics(x, y, p, &wid, &hig, &h_a, &v_a);
y += v_a;
}
}
if (pix_fmt != PIX_FMT_RGBA32) {
if (img_convert(picture, pix_fmt,
&picture1, PIX_FMT_RGBA32, width, height) < 0) {
}
}
done:
;
}
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;
}
/*
Dual wallpaper generator
Copyright (C) 2009 Aleksi Räsänen <*****@*****.**>
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero 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 Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
int
main( int argc, char *argv[] )
{
Imlib_Image input_image;
Imlib_Image output_image;
int image1_width, image1_height, image2_width, image2_height;
int input_width, input_height, output_width;
if( argc < 7 )
{
printf( "Usage: %s inputfile img1_width img1_height ", argv[0] );
printf( "img2_width img2_height output.jpg\n" );
exit(1);
}
// Check if input file exists or not. If not, quit.
FILE *fp;
fp = fopen( argv[1], "r" );
if( fp == NULL )
{
printf( "File %s not found!\n", argv[1] );
exit(1);
}
// Read output image dimensions
image1_width = atoi( argv[2] );
image1_height = atoi( argv[3] );
image2_width = atoi( argv[4] );
image2_height = atoi( argv[5] );
input_image = imlib_load_image( argv[1] );
// Output image width must be selected by wider image
if( image1_width > image2_width )
output_width = image1_width;
else
output_width = image2_width;
// Create new empty image
output_image = imlib_create_image( output_width,
image1_height + image2_height );
if(! input_image )
{
printf( "Failed to load image %s\n", argv[1] );
exit(1);
}
// Read original image size
imlib_context_set_image( input_image );
input_width = imlib_image_get_width();
input_height = imlib_image_get_height();
imlib_context_set_image( output_image );
// Copy whole input image to output image
imlib_blend_image_onto_image( input_image, 0, 0, 0,
input_width, input_height,
0, 0,
image1_width, image1_height );
imlib_blend_image_onto_image( input_image, 0, 0, 0,
input_width, input_height,
0, image1_height,
image2_width, image2_height );
imlib_save_image( argv[6] );
return 0;
}
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;
}
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
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;
}
/* TODO s/bit/lot */
void init_thumbnail_mode(void)
{
/* moved to thumbnail_data:
Imlib_Image im_main;
Imlib_Image bg_im = NULL;
Imlib_Font fn = NULL;
Imlib_Font title_fn = NULL;
int w = 800, h = 600;
int bg_w = 0, bg_h = 0;
int text_area_w, text_area_h;
int max_column_w = 0;
*/
Imlib_Image im_temp;
int ww = 0, hh = 0, www, hhh, xxx, yyy;
int x = 0, y = 0;
winwidget winwid = NULL;
Imlib_Image im_thumb = NULL;
unsigned char trans_bg = 0;
int title_area_h = 0;
int tw = 0, th = 0;
int fw_name, fw_size, fw_dim, fh;
int thumbnailcount = 0;
feh_file *file = NULL;
gib_list *l, *last = NULL;
int lines;
int index_image_width, index_image_height;
int x_offset_name = 0, x_offset_dim = 0, x_offset_size = 0;
char *s;
unsigned int thumb_counter = 0;
/* initialize thumbnail mode data */
td.im_main = NULL;
td.im_bg = NULL;
td.font_main = NULL;
td.font_title = NULL;
td.w = 640;
td.h = 480;
td.bg_w = 0;
td.bg_h = 0;
td.thumb_tot_h = 0;
td.text_area_w = 0;
td.text_area_h = 0;
td.vertical = 0;
td.max_column_w = 0;
mode = "thumbnail";
if (opt.font)
td.font_main = gib_imlib_load_font(opt.font);
if (!td.font_main)
td.font_main = gib_imlib_load_font(DEFAULT_FONT);
if (opt.title_font) {
int fh, fw;
td.font_title = gib_imlib_load_font(opt.title_font);
gib_imlib_get_text_size(td.font_title, "W", NULL, &fw, &fh,
IMLIB_TEXT_TO_RIGHT);
title_area_h = fh + 4;
} else
td.font_title = imlib_load_font(DEFAULT_FONT_TITLE);
if ((!td.font_main) || (!td.font_title))
eprintf("Error loading fonts");
/* Work out how tall the font is */
gib_imlib_get_text_size(td.font_main, "W", NULL, &tw, &th,
IMLIB_TEXT_TO_RIGHT);
/* For now, allow room for the right number of lines with small gaps */
td.text_area_h = ((th + 2) * (opt.index_show_name + opt.index_show_size +
opt.index_show_dim)) + 5;
/* This includes the text area for index data */
td.thumb_tot_h = opt.thumb_h + td.text_area_h;
/* Use bg image dimensions for default size */
if (opt.bg && opt.bg_file) {
if (!strcmp(opt.bg_file, "trans"))
trans_bg = 1;
else {
D(3, ("Time to apply a background to blend onto\n"));
if (feh_load_image_char(&td.im_bg, opt.bg_file) != 0) {
td.bg_w = gib_imlib_image_get_width(td.im_bg);
td.bg_h = gib_imlib_image_get_height(td.im_bg);
}
}
}
/* figure out geometry for the main window and entries */
feh_thumbnail_calculate_geometry();
index_image_width = td.w;
index_image_height = td.h + title_area_h;
td.im_main = imlib_create_image(index_image_width, index_image_height);
gib_imlib_image_set_has_alpha(td.im_main, 1);
if (!td.im_main)
eprintf("Imlib error creating index image, are you low on RAM?");
if (td.im_bg)
gib_imlib_blend_image_onto_image(td.im_main, td.im_bg,
gib_imlib_image_has_alpha
(td.im_bg), 0, 0, td.bg_w, td.bg_h, 0, 0,
td.w, td.h, 1, 0, 0);
else if (trans_bg) {
gib_imlib_image_fill_rectangle(td.im_main, 0, 0, td.w,
td.h + title_area_h, 0, 0, 0, 0);
gib_imlib_image_set_has_alpha(td.im_main, 1);
} else {
/* Colour the background */
gib_imlib_image_fill_rectangle(td.im_main, 0, 0, td.w,
td.h + title_area_h, 0, 0, 0, 255);
}
/* Create title now */
if (!opt.title)
s = estrdup(PACKAGE " [thumbnail mode]");
else
s = estrdup(feh_printf(opt.title, NULL));
if (opt.display) {
winwid = winwidget_create_from_image(td.im_main, s, WIN_TYPE_THUMBNAIL);
winwidget_show(winwid);
}
/* make sure we have an ~/.thumbnails/normal directory for storing
permanent thumbnails */
td.cache_thumbnails = opt.cache_thumbnails;
if (td.cache_thumbnails) {
if (opt.thumb_w > opt.thumb_h)
td.cache_dim = opt.thumb_w;
else
td.cache_dim = opt.thumb_h;
if (td.cache_dim > 256) {
/* No caching as specified by standard. Sort of. */
td.cache_thumbnails = 0;
} else if (td.cache_dim > 128) {
td.cache_dim = 256;
td.cache_dir = estrdup("large");
} else {
td.cache_dim = 128;
td.cache_dir = estrdup("normal");
}
feh_thumbnail_setup_thumbnail_dir();
}
for (l = filelist; l; l = l->next) {
file = FEH_FILE(l->data);
if (last) {
filelist = feh_file_remove_from_list(filelist, last);
last = NULL;
}
D(4, ("About to load image %s\n", file->filename));
/* if (feh_load_image(&im_temp, file) != 0) */
if (feh_thumbnail_get_thumbnail(&im_temp, file) != 0) {
if (opt.verbose)
feh_display_status('.');
D(4, ("Successfully loaded %s\n", file->filename));
www = opt.thumb_w;
hhh = opt.thumb_h;
ww = gib_imlib_image_get_width(im_temp);
hh = gib_imlib_image_get_height(im_temp);
thumbnailcount++;
if (gib_imlib_image_has_alpha(im_temp))
imlib_context_set_blend(1);
else
imlib_context_set_blend(0);
if (opt.aspect) {
double ratio = 0.0;
/* Keep the aspect ratio for the thumbnail */
ratio = ((double) ww / hh) / ((double) www / hhh);
if (ratio > 1.0)
hhh = opt.thumb_h / ratio;
else if (ratio != 1.0)
www = opt.thumb_w * ratio;
}
if ((!opt.stretch) && ((www > ww) || (hhh > hh))) {
/* Don't make the image larger unless stretch is specified */
www = ww;
hhh = hh;
}
im_thumb = gib_imlib_create_cropped_scaled_image(im_temp, 0, 0,
ww, hh, www, hhh, 1);
gib_imlib_free_image_and_decache(im_temp);
if (opt.alpha) {
DATA8 atab[256];
D(3, ("Applying alpha options\n"));
gib_imlib_image_set_has_alpha(im_thumb, 1);
memset(atab, opt.alpha_level, sizeof(atab));
gib_imlib_apply_color_modifier_to_rectangle
(im_thumb, 0, 0, www, hhh, NULL, NULL, NULL, atab);
}
td.text_area_w = opt.thumb_w;
/* Now draw on the info text */
if (opt.index_show_name) {
gib_imlib_get_text_size(td.font_main, file->name, NULL,
&fw_name, &fh, IMLIB_TEXT_TO_RIGHT);
if (fw_name > td.text_area_w)
td.text_area_w = fw_name;
}
if (opt.index_show_dim) {
gib_imlib_get_text_size(td.font_main,
create_index_dimension_string(ww, hh),
NULL, &fw_dim, &fh, IMLIB_TEXT_TO_RIGHT);
if (fw_dim > td.text_area_w)
td.text_area_w = fw_dim;
}
if (opt.index_show_size) {
gib_imlib_get_text_size(td.font_main,
create_index_size_string(file->filename),
NULL, &fw_size, &fh, IMLIB_TEXT_TO_RIGHT);
if (fw_size > td.text_area_w)
td.text_area_w = fw_size;
}
if (td.text_area_w > opt.thumb_w)
td.text_area_w += 5;
/* offsets for centering text */
x_offset_name = (td.text_area_w - fw_name) / 2;
x_offset_dim = (td.text_area_w - fw_dim) / 2;
x_offset_size = (td.text_area_w - fw_size) / 2;
if (td.vertical) {
if (td.text_area_w > td.max_column_w)
td.max_column_w = td.text_area_w;
if (y > td.h - td.thumb_tot_h) {
y = 0;
x += td.max_column_w;
td.max_column_w = 0;
}
if (x > td.w - td.text_area_w)
break;
} else {
if (x > td.w - td.text_area_w) {
x = 0;
y += td.thumb_tot_h;
}
if (y > td.h - td.thumb_tot_h)
break;
}
/* center image relative to the text below it (if any) */
xxx = x + ((td.text_area_w - www) / 2);
yyy = y;
if (opt.aspect)
yyy += (opt.thumb_h - hhh) / 2;
/* Draw now */
gib_imlib_blend_image_onto_image(td.im_main,
im_thumb,
gib_imlib_image_has_alpha
(im_thumb), 0, 0,
www, hhh, xxx,
yyy, www, hhh, 1,
gib_imlib_image_has_alpha(im_thumb), 0);
thumbnails = gib_list_add_front(thumbnails,
feh_thumbnail_new(file, xxx, yyy, www, hhh));
gib_imlib_free_image_and_decache(im_thumb);
lines = 0;
if (opt.index_show_name)
gib_imlib_text_draw(td.im_main,
td.font_main, NULL,
x + x_offset_name,
y + opt.thumb_h + (lines++ * (th + 2)) + 2,
file->name, IMLIB_TEXT_TO_RIGHT,
255, 255, 255, 255);
if (opt.index_show_dim)
gib_imlib_text_draw(td.im_main,
td.font_main, NULL,
x + x_offset_dim,
y + opt.thumb_h + (lines++ * (th + 2)) + 2,
create_index_dimension_string(ww, hh),
IMLIB_TEXT_TO_RIGHT, 255, 255, 255, 255);
if (opt.index_show_size)
gib_imlib_text_draw(td.im_main,
td.font_main, NULL,
x + x_offset_size,
y + opt.thumb_h + (lines++ * (th + 2)) + 2,
create_index_size_string(file->filename),
IMLIB_TEXT_TO_RIGHT, 255, 255, 255, 255);
if (td.vertical)
y += td.thumb_tot_h;
else
x += td.text_area_w;
} else {
if (opt.verbose)
feh_display_status('x');
last = l;
}
if (opt.display) {
/* thumb_counter is unsigned, so no need to catch overflows */
if (++thumb_counter == opt.thumb_redraw) {
winwidget_render_image(winwid, 0, 0);
thumb_counter = 0;
}
if (!feh_main_iteration(0))
exit(0);
}
}
if (thumb_counter != 0)
winwidget_render_image(winwid, 0, 0);
if (opt.verbose)
fprintf(stdout, "\n");
if (opt.title_font) {
int fw, fh, fx, fy;
char *s;
s = create_index_title_string(thumbnailcount, td.w, td.h);
gib_imlib_get_text_size(td.font_title, s, NULL, &fw, &fh,
IMLIB_TEXT_TO_RIGHT);
fx = (index_image_width - fw) >> 1;
fy = index_image_height - fh - 2;
gib_imlib_text_draw(td.im_main, td.font_title, NULL, fx,
fy, s, IMLIB_TEXT_TO_RIGHT, 255, 255, 255, 255);
}
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;
}
void feh_menu_redraw(feh_menu * m)
{
Imlib_Updates u, uu;
if ((!m->needs_redraw) || (!m->visible) || (!m->updates))
return;
m->needs_redraw = 0;
if (!m->pmap)
m->pmap = XCreatePixmap(disp, m->win, m->w, m->h, depth);
XSetWindowBackgroundPixmap(disp, m->win, m->pmap);
u = imlib_updates_merge_for_rendering(m->updates, m->w, m->h);
m->updates = NULL;
if (u) {
D(("I have updates to render\n"));
for (uu = u; u; u = imlib_updates_get_next(u)) {
int x, y, w, h;
Imlib_Image im;
imlib_updates_get_coordinates(u, &x, &y, &w, &h);
D(("update coords %d,%d %d*%d\n", x, y, w, h));
im = imlib_create_image(w, h);
gib_imlib_image_fill_rectangle(im, 0, 0, w, h, 0, 0, 0, 0);
if (im) {
feh_menu_draw_to_buf(m, im, x, y);
gib_imlib_render_image_on_drawable(m->pmap, im, x, y, 1, 0, 0);
gib_imlib_free_image(im);
XClearArea(disp, m->win, x, y, w, h, False);
}
}
imlib_updates_free(uu);
}
return;
}
