static void
glw_text_bitmap_layout(glw_t *w, const glw_rctx_t *rc)
{
glw_text_bitmap_t *gtb = (void *)w;
glw_root_t *gr = w->glw_root;
gr->gr_can_externalize = 0;
// Initialize renderers
if(unlikely(!glw_renderer_initialized(>b->gtb_text_renderer)))
glw_renderer_init_quad(>b->gtb_text_renderer);
if(w->glw_class == &glw_text &&
unlikely(!glw_renderer_initialized(>b->gtb_cursor_renderer)))
glw_renderer_init_quad(>b->gtb_cursor_renderer);
if(gtb->gtb_background_alpha > GLW_ALPHA_EPSILON &&
unlikely(!glw_renderer_initialized(>b->gtb_cursor_renderer))) {
glw_renderer_init_quad(>b->gtb_background_renderer);
glw_renderer_vtx_pos(>b->gtb_background_renderer, 0, -1, -1, 0);
glw_renderer_vtx_pos(>b->gtb_background_renderer, 1, 1, -1, 0);
glw_renderer_vtx_pos(>b->gtb_background_renderer, 2, 1, 1, 0);
glw_renderer_vtx_pos(>b->gtb_background_renderer, 3, -1, 1, 0);
}
// Upload texture
image_component_t *ic = image_find_component(gtb->gtb_image, IMAGE_PIXMAP);
if(ic != NULL) {
glw_tex_upload(gr, >b->gtb_texture, ic->pm, 0);
gtb->gtb_margin = ic->pm->pm_margin;
image_clear_component(ic);
gtb->gtb_need_layout = 1;
}
const int tex_width = glw_tex_width(>b->gtb_texture);
const int tex_height = glw_tex_height(>b->gtb_texture);
ic = image_find_component(gtb->gtb_image, IMAGE_TEXT_INFO);
image_component_text_info_t *ti = ic ? &ic->text_info : NULL;
// Check if we need to repaint
if(gtb->gtb_saved_width != rc->rc_width ||
gtb->gtb_saved_height != rc->rc_height) {
if(ti != NULL && gtb->gtb_state == GTB_VALID) {
if(ti->ti_flags & IMAGE_TEXT_WRAPPED)
gtb->gtb_state = GTB_NEED_RENDER;
if(rc->rc_width > gtb->gtb_saved_width &&
ti->ti_flags & IMAGE_TEXT_TRUNCATED)
gtb->gtb_state = GTB_NEED_RENDER;
if(gtb->gtb_flags & GTB_ELLIPSIZE) {
if(ti->ti_flags & IMAGE_TEXT_TRUNCATED) {
gtb->gtb_state = GTB_NEED_RENDER;
} else {
if(rc->rc_width - gtb->gtb_padding[2] - gtb->gtb_padding[0] <
tex_width - gtb->gtb_margin * 2)
gtb->gtb_state = GTB_NEED_RENDER;
if(rc->rc_height - gtb->gtb_padding[1] - gtb->gtb_padding[3] <
tex_height - gtb->gtb_margin * 2)
gtb->gtb_state = GTB_NEED_RENDER;
}
}
}
gtb->gtb_saved_width = rc->rc_width;
gtb->gtb_saved_height = rc->rc_height;
gtb->gtb_update_cursor = 1;
gtb->gtb_need_layout = 1;
if(gtb->w.glw_flags2 & GLW2_DEBUG)
printf(" textbitmap: Parent widget gives us :%d x %d ti=%p\n",
rc->rc_width, rc->rc_height, ti);
}
if(ti != NULL && gtb->gtb_need_layout) {
const int margin = gtb->gtb_margin;
int left = gtb->gtb_padding[0] - margin;
int top = rc->rc_height - gtb->gtb_padding[1] + margin;
int right = rc->rc_width - gtb->gtb_padding[2] + margin;
int bottom = gtb->gtb_padding[3] - margin;
int text_width = tex_width;
int text_height = tex_height;
float x1, y1, x2, y2;
if(gtb->w.glw_flags2 & GLW2_DEBUG)
printf(" textbitmap: text_width:%d left:%d right:%d margin:%d\n",
text_width, left, right, margin);
// Vertical
if(text_height > top - bottom) {
// Oversized, must cut
text_height = top - bottom;
} else {
switch(w->glw_alignment) {
case LAYOUT_ALIGN_CENTER:
case LAYOUT_ALIGN_LEFT:
case LAYOUT_ALIGN_RIGHT:
bottom = (bottom + top - text_height) / 2;
top = bottom + text_height;
break;
case LAYOUT_ALIGN_TOP_LEFT:
case LAYOUT_ALIGN_TOP_RIGHT:
case LAYOUT_ALIGN_TOP:
case LAYOUT_ALIGN_JUSTIFIED:
bottom = top - tex_height;
break;
case LAYOUT_ALIGN_BOTTOM:
case LAYOUT_ALIGN_BOTTOM_LEFT:
case LAYOUT_ALIGN_BOTTOM_RIGHT:
top = bottom + tex_height;
break;
}
}
y1 = -1.0f + 2.0f * bottom / (float)rc->rc_height;
y2 = -1.0f + 2.0f * top / (float)rc->rc_height;
// Horizontal
if(text_width > right - left || ti->ti_flags & IMAGE_TEXT_TRUNCATED) {
// Oversized, must cut
text_width = right - left;
if(gtb->w.glw_flags2 & GLW2_DEBUG)
printf(" textbitmap: Oversized, must cut. Width is now %d\n",
text_width);
#if 0
if(!(gtb->gtb_flags & GTB_ELLIPSIZE)) {
glw_renderer_vtx_col(>b->gtb_text_renderer, 0, 1,1,1,1+text_width/20);
glw_renderer_vtx_col(>b->gtb_text_renderer, 1, 1,1,1,0);
glw_renderer_vtx_col(>b->gtb_text_renderer, 2, 1,1,1,0);
glw_renderer_vtx_col(>b->gtb_text_renderer, 3, 1,1,1,1+text_width/20);
}
#endif
} else {
glw_renderer_vtx_col_reset(>b->gtb_text_renderer);
switch(w->glw_alignment) {
case LAYOUT_ALIGN_JUSTIFIED:
case LAYOUT_ALIGN_CENTER:
case LAYOUT_ALIGN_BOTTOM:
case LAYOUT_ALIGN_TOP:
left = (left + right - text_width) / 2;
right = left + text_width;
break;
case LAYOUT_ALIGN_LEFT:
case LAYOUT_ALIGN_TOP_LEFT:
case LAYOUT_ALIGN_BOTTOM_LEFT:
right = left + tex_width;
break;
case LAYOUT_ALIGN_RIGHT:
case LAYOUT_ALIGN_TOP_RIGHT:
case LAYOUT_ALIGN_BOTTOM_RIGHT:
left = right - tex_width;
break;
}
}
x1 = -1.0f + 2.0f * left / (float)rc->rc_width;
x2 = -1.0f + 2.0f * right / (float)rc->rc_width;
const float s = text_width / (float)tex_width;
const float t = text_height / (float)tex_height;
if(gtb->w.glw_flags2 & GLW2_DEBUG)
printf(" s=%f t=%f\n", s, t);
glw_renderer_vtx_pos(>b->gtb_text_renderer, 0, x1, y1, 0.0);
glw_renderer_vtx_st (>b->gtb_text_renderer, 0, 0, t);
glw_renderer_vtx_pos(>b->gtb_text_renderer, 1, x2, y1, 0.0);
glw_renderer_vtx_st (>b->gtb_text_renderer, 1, s, t);
glw_renderer_vtx_pos(>b->gtb_text_renderer, 2, x2, y2, 0.0);
glw_renderer_vtx_st (>b->gtb_text_renderer, 2, s, 0);
glw_renderer_vtx_pos(>b->gtb_text_renderer, 3, x1, y2, 0.0);
glw_renderer_vtx_st (>b->gtb_text_renderer, 3, 0, 0);
}
if(w->glw_class == &glw_text && gtb->gtb_update_cursor &&
gtb->gtb_state == GTB_VALID) {
int i = gtb->gtb_edit_ptr;
int left;
float x1, y1, x2, y2;
if(ti != NULL && ti->ti_charpos != NULL) {
if(i < ti->ti_charposlen) {
left = ti->ti_charpos[i*2 ];
} else {
left = ti->ti_charpos[2 * ti->ti_charposlen - 1];
}
} else {
left = 0;
}
left += gtb->gtb_padding[0];
x1 = -1.0f + 2.0f * (left - 1) / (float)rc->rc_width;
x2 = -1.0f + 2.0f * (left ) / (float)rc->rc_width;
y1 = -1.0f + 2.0f * gtb->gtb_padding[3] / (float)rc->rc_height;
y2 = 1.0f - 2.0f * gtb->gtb_padding[1] / (float)rc->rc_height;
glw_renderer_vtx_pos(>b->gtb_cursor_renderer, 0, x1, y1, 0.0);
glw_renderer_vtx_pos(>b->gtb_cursor_renderer, 1, x2, y1, 0.0);
glw_renderer_vtx_pos(>b->gtb_cursor_renderer, 2, x2, y2, 0.0);
glw_renderer_vtx_pos(>b->gtb_cursor_renderer, 3, x1, y2, 0.0);
if(w->glw_flags2 & GLW2_DEBUG) {
printf("Cursor updated %f %f %f %f rect:%d,%d\n",
x1, y1, x2, y2, rc->rc_width, rc->rc_height);
}
gtb->gtb_update_cursor = 0;
}
gtb->gtb_paint_cursor =
gtb->gtb_flags & GTB_PERMANENT_CURSOR ||
(w->glw_class == &glw_text && glw_is_focused(w));
if(gtb->gtb_paint_cursor && rc->rc_alpha > GLW_ALPHA_EPSILON)
glw_need_refresh(gr, 0);
gtb->gtb_need_layout = 0;
if(gtb->gtb_state == GTB_VALID && gtb->gtb_deferred_realize) {
gtb->gtb_deferred_realize = 0;
gtb_realize(gtb);
}
if(gtb->gtb_state != GTB_NEED_RENDER)
return;
TAILQ_INSERT_TAIL(&gr->gr_gtb_render_queue, gtb, gtb_workq_link);
gtb->gtb_state = GTB_QUEUED_FOR_RENDERING;
hts_cond_signal(&gr->gr_gtb_work_cond);
}
static int
hc_image(http_connection_t *hc, const char *remain, void *opaque,
http_cmd_t method)
{
htsbuf_queue_t out;
image_t *img;
char errbuf[200];
const char *content;
image_meta_t im = {0};
im.im_no_decoding = 1;
rstr_t *url;
const char *u = http_arg_get_req(hc, "url");
if(u != NULL) {
url = rstr_alloc(u);
url_deescape(rstr_data(url));
} else {
if(remain == NULL) {
return 404;
}
url = rstr_alloc(remain);
}
img = backend_imageloader(url, &im, NULL, errbuf, sizeof(errbuf), NULL,
NULL);
rstr_release(url);
if(img == NULL)
return http_error(hc, 404, "Unable to load image %s : %s",
remain, errbuf);
const image_component_t *ic = image_find_component(img, IMAGE_CODED);
if(ic == NULL) {
image_release(img);
return http_error(hc, 404,
"Unable to load image %s : Original data not available",
remain);
}
const image_component_coded_t *icc = &ic->coded;
htsbuf_queue_init(&out, 0);
htsbuf_append(&out, buf_cstr(icc->icc_buf), buf_len(icc->icc_buf));
switch(icc->icc_type) {
case IMAGE_JPEG:
content = "image/jpeg";
break;
case IMAGE_PNG:
content = "image/png";
break;
case IMAGE_GIF:
content = "image/gif";
break;
default:
content = "image";
break;
}
image_release(img);
return http_send_reply(hc, 0, content, NULL, NULL, 0, &out);
}
