static struct sequ_image *im2_image_open(char *name)
{
sequ_image *ret;
Imlib_Image img;
if(!name || !im2_initialized)
return NULL;
/* load the data */
img=imlib_load_image_immediately_without_cache(name);
if(img == NULL)
{
print_err("Error: Loading an image with imlib2 failed\n");
return NULL;
}
print_debug("%s: kuvan osoite on %p\n",THIS_FUNCTION,img);
/* construct the image */
ret=malloc(sizeof(sequ_image));
img_from_im2(ret,img);
return ret;
}
static inline ImageObject *
_imlib2_open(char *filename, int use_cache)
{
Imlib_Image *image;
Imlib_Load_Error error = IMLIB_LOAD_ERROR_NONE;
if (use_cache){
image = imlib_load_image_with_error_return(filename, &error);
}else{
image = imlib_load_image_immediately_without_cache(filename);
}
CHECK_LOAD_ERROR(error);
#ifdef DEVELOP
imlib_context_set_image(image);
DEBUG("width %d", imlib_image_get_width());
DEBUG("height %d", imlib_image_get_height());
#endif
return ImageObject_New(image);
}
Image<uint32_t> load_image(const char* filename)
{
Image<uint32_t> res;
Imlib_Image image_handle = NULL;
image_handle = imlib_load_image_immediately_without_cache(filename);
if(image_handle) {
res.width = imlib_image_get_width();
res.height = imlib_image_get_height();
res.channels = 4; // ARGB
res.data.set_size(res.width * res.height * res.channels);
res.format = Image<uint32_t>::ARGB;
DATA32* raw = imlib_image_get_data_for_reading_only(); // ARGB handle
memcpy(res.data.ptr(), raw, res.width * res.height * sizeof(DATA32));
imlib_free_image();
}
return res;
}
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 addLogout(int x,int y,int grav,bool fromleft)
{
const char *themedicon=NULL;
const char *icon=NULL;
int xpos=x;
int ypos=y;
int width=0;
int height=0;
int thisgrav=grav;
int iconsize=16;
if(logoutButton!=NULL)
{
printError("Duplicate logout");
return(0);
}
setSizes(&xpos,&ypos,&width,&height,&iconsize,&thisgrav,fromleft);
logoutButton=new LFSTK_menuButtonClass(mainwind,"",xpos,ypos,width,height,thisgrav);
icon=mainwind->globalLib->LFSTK_findThemedIcon(desktopTheme,logoutIconNames[NUMLOGOUTENTRYS],"");
if(icon!=NULL)
logoutButton->LFSTK_setImageFromPath(icon,iconsize,iconsize);
else
logoutButton->LFSTK_setIconFromPath(DATADIR "/pixmaps/exit.png",iconsize);
logoutButton->LFSTK_setCallBack(logoutCB,NULL,NULL);
logoutItems=new menuItemStruct[NUMLOGOUTENTRYS];
for(int j=LOGOUT;j<NUMLOGOUTENTRYS;j++)
{
logoutItems[j].label=strdup(logoutLabels[j]);
logoutItems[j].userData=(void*)(long)j;
logoutItems[j].bc=NULL;
logoutItems[j].subMenus=NULL;
logoutItems[j].subMenuCnt=0;
logoutItems[j].useIcon=false;
logoutItems[j].useImage=true;
logoutItems[j].iconSize=iconSize;
themedicon=mainwind->globalLib->LFSTK_findThemedIcon(desktopTheme,logoutIconNames[j],"");
if(themedicon!=NULL)
{
logoutItems[j].image=imlib_load_image_immediately_without_cache(themedicon);
logoutItems[j].imageWidth=iconSize;
logoutItems[j].imageHeight=iconSize;
}
else
{
logoutItems[j].image=imlib_load_image_immediately_without_cache(logoutImages[j]);
logoutItems[j].imageWidth=iconSize;
logoutItems[j].imageHeight=iconSize;
}
}
logoutButton->LFSTK_setStyle(BEVELOUT);
logoutButton->LFSTK_setLabelOriention(CENTRE);
logoutButton->LFSTK_setCallBack(NULL,logoutCB,NULL);
logoutButton->LFSTK_addMenus(logoutItems,NUMLOGOUTENTRYS);
return(width);
}
int resize_launcher(void *obj)
{
Launcher *launcher = obj;
GSList *l;
int count, icon_size;
int icons_per_column=1, icons_per_row=1, marging=0;
if (panel_horizontal) {
icon_size = launcher->area.height;
} else {
icon_size = launcher->area.width;
}
icon_size = icon_size - (2 * launcher->area.bg->border.width) - (2 * launcher->area.paddingy);
if (launcher_max_icon_size > 0 && icon_size > launcher_max_icon_size)
icon_size = launcher_max_icon_size;
// Resize icons if necessary
for (l = launcher->list_icons; l ; l = l->next) {
LauncherIcon *launcherIcon = (LauncherIcon *)l->data;
if (launcherIcon->icon_size != icon_size || !launcherIcon->icon_original) {
launcherIcon->icon_size = icon_size;
launcherIcon->area.width = launcherIcon->icon_size;
launcherIcon->area.height = launcherIcon->icon_size;
// Get the path for an icon file with the new size
char *new_icon_path = get_icon_path(launcher->list_themes, launcherIcon->icon_name, launcherIcon->icon_size);
if (!new_icon_path) {
// Draw a blank icon
free_icon(launcherIcon->icon_original);
launcherIcon->icon_original = NULL;
free_icon(launcherIcon->icon_scaled);
launcherIcon->icon_scaled = NULL;
continue;
}
if (launcherIcon->icon_path && strcmp(new_icon_path, launcherIcon->icon_path) == 0) {
// If it's the same file just rescale
free_icon(launcherIcon->icon_scaled);
launcherIcon->icon_scaled = scale_icon(launcherIcon->icon_original, icon_size);
free(new_icon_path);
fprintf(stderr, "launcher.c %d: Using icon %s\n", __LINE__, launcherIcon->icon_path);
} else {
// Free the old files
free_icon(launcherIcon->icon_original);
free_icon(launcherIcon->icon_scaled);
launcherIcon->icon_original = launcherIcon->icon_scaled = NULL;
// Load the new file and scale
#ifdef HAVE_RSVG
if (g_str_has_suffix(new_icon_path, ".svg")) {
GError* err = NULL;
RsvgHandle* svg = rsvg_handle_new_from_file(new_icon_path, &err);
if (err != NULL) {
fprintf(stderr, "Could not load svg image!: %s", err->message);
g_error_free(err);
launcherIcon->icon_original = NULL;
} else {
char suffix[128];
sprintf(suffix, "tmpicon-%d.png", getpid());
gchar *name = g_build_filename(g_get_user_config_dir(), "tint2", suffix, NULL);
GdkPixbuf *pixbuf = rsvg_handle_get_pixbuf(svg);
gdk_pixbuf_save(pixbuf, name, "png", NULL, NULL);
launcherIcon->icon_original = imlib_load_image_immediately_without_cache(name);
g_remove(name);
g_free(name);
g_object_unref(G_OBJECT(pixbuf));
g_object_unref(G_OBJECT(svg));
}
} else
#endif
{
launcherIcon->icon_original = imlib_load_image_immediately(new_icon_path);
}
// On loading error, fallback to default
if (!launcherIcon->icon_original) {
free(new_icon_path);
new_icon_path = get_icon_path(launcher->list_themes, DEFAULT_ICON, launcherIcon->icon_size);
if (new_icon_path)
launcherIcon->icon_original = imlib_load_image_immediately(new_icon_path);
}
if (!launcherIcon->icon_original) {
// Loading default icon failed, draw a blank icon
free(new_icon_path);
} else {
// Loaded icon successfully
launcherIcon->icon_scaled = scale_icon(launcherIcon->icon_original, launcherIcon->icon_size);
free(launcherIcon->icon_path);
launcherIcon->icon_path = new_icon_path;
fprintf(stderr, "launcher.c %d: Using icon %s\n", __LINE__, launcherIcon->icon_path);
}
}
}
}
count = g_slist_length(launcher->list_icons);
if (panel_horizontal) {
if (!count) {
launcher->area.width = 0;
} else {
int height = launcher->area.height - 2*launcher->area.bg->border.width - 2*launcher->area.paddingy;
// here icons_per_column always higher than 0
icons_per_column = (height+launcher->area.paddingx) / (icon_size+launcher->area.paddingx);
marging = height - (icons_per_column-1)*(icon_size+launcher->area.paddingx) - icon_size;
icons_per_row = count / icons_per_column + (count%icons_per_column != 0);
launcher->area.width = (2 * launcher->area.bg->border.width) +
(2 * launcher->area.paddingxlr) +
(icon_size * icons_per_row) +
((icons_per_row-1) * launcher->area.paddingx);
}
}
else {
if (!count) {
launcher->area.height = 0;
} else {
int width = launcher->area.width - 2*launcher->area.bg->border.width - 2*launcher->area.paddingy;
// here icons_per_row always higher than 0
icons_per_row = (width+launcher->area.paddingx) / (icon_size+launcher->area.paddingx);
marging = width - (icons_per_row-1)*(icon_size+launcher->area.paddingx) - icon_size;
icons_per_column = count / icons_per_row+ (count%icons_per_row != 0);
launcher->area.height = (2 * launcher->area.bg->border.width) +
(2 * launcher->area.paddingxlr) +
(icon_size * icons_per_column) +
((icons_per_column-1) * launcher->area.paddingx);
}
}
int i, posx, posy;
int start = launcher->area.bg->border.width + launcher->area.paddingy + marging/2;
if (panel_horizontal) {
posy = start;
posx = launcher->area.bg->border.width + launcher->area.paddingxlr;
} else {
posx = start;
posy = launcher->area.bg->border.width + launcher->area.paddingxlr;
}
for (i=1, l = launcher->list_icons; l ; i++, l = l->next) {
LauncherIcon *launcherIcon = (LauncherIcon*)l->data;
launcherIcon->y = posy;
launcherIcon->x = posx;
launcherIcon->area.posy = ((Area*)launcherIcon->area.parent)->posy + launcherIcon->y;
launcherIcon->area.posx = ((Area*)launcherIcon->area.parent)->posx + launcherIcon->x;
launcherIcon->area.width = launcherIcon->icon_size;
launcherIcon->area.height = launcherIcon->icon_size;
//printf("launcher %d : %d,%d\n", i, posx, posy);
if (panel_horizontal) {
if (i % icons_per_column) {
posy += icon_size + launcher->area.paddingx;
} else {
posy = start;
posx += (icon_size + launcher->area.paddingx);
}
} else {
if (i % icons_per_row) {
posx += icon_size + launcher->area.paddingx;
} else {
posx = start;
posy += (icon_size + launcher->area.paddingx);
}
}
}
return 1;
}
