void AllegroTextBox::Draw()
{
int bbx;
int bby;
int bbw;
int bbh;
QString display = m_value;
if (m_passwordMode)
display.fill('*');
al_get_text_dimensions(m_boxFont, display.toStdString().c_str(), &bbx, &bby, &bbw, &bbh);
int x1 = GetXPos();
int y1 = GetYPos();
int x2 = x1 + GetWidth();
int y2 = y1 + GetHeight();
al_draw_filled_rectangle(x1, y1, x2, y2, m_backgroundColor);
al_draw_rectangle(x1, y1, x2, y2, GetFocus() ? m_focusedBorder : m_defaultBorder, 1);
bool Overflow = (bbw > GetWidth() - m_sidePadding * 2);
al_set_clipping_rectangle((m_xPos+m_sidePadding), m_yPos, (GetWidth()-m_sidePadding*2), GetHeight());
al_draw_text(m_boxFont, m_textColor, Overflow ? (m_xPos+GetWidth()-m_sidePadding) : (m_xPos+m_sidePadding), (m_yPos + (GetHeight() / 2) - bbh/2), Overflow ? ALLEGRO_ALIGN_RIGHT : ALLEGRO_ALIGN_LEFT, display.toStdString().c_str());
al_reset_clipping_rectangle();
}
Tamanho Tela::tamanho_texto(const char *s) {
Tamanho tam;
int bbx, bby, bbw, bbh;
al_get_text_dimensions(fonte, s, &bbx, &bby, &bbw, &bbh);
tam.larg = bbw;
tam.alt = bbh;
return tam;
}
void init_error_bitmap() {
// Error bitmap.
int bmp_error_w, bmp_error_h;
al_get_text_dimensions(al_create_builtin_font(), "ERROR", NULL, NULL, &bmp_error_w, &bmp_error_h);
bmp_error = al_create_bitmap(bmp_error_w, bmp_error_h);
al_set_target_bitmap(bmp_error); {
al_clear_to_color(al_map_rgba(64, 0, 0, 128));
al_draw_text(al_create_builtin_font(), al_map_rgb(255, 0, 0), 0, 0, 0, "ERROR");
} al_set_target_backbuffer(display);
}
static int allua_Font_get_text_dimensions(lua_State * L)
{
ALLUA_font font = allua_check_font(L, 1);
const char *text = luaL_checkstring(L, 2);
int bbx;
int bby;
int bbw;
int bbh;
al_get_text_dimensions(font, text, &bbx, &bby, &bbw, &bbh);
lua_pushinteger(L, bbx);
lua_pushinteger(L, bby);
lua_pushinteger(L, bbw);
lua_pushinteger(L, bbh);
return 4;
}
static void render(void)
{
ALLEGRO_COLOR white = al_map_rgba_f(1, 1, 1, 1);
ALLEGRO_COLOR black = al_map_rgba_f(0, 0, 0, 1);
ALLEGRO_COLOR red = al_map_rgba_f(1, 0, 0, 1);
ALLEGRO_COLOR green = al_map_rgba_f(0, 0.5, 0, 1);
ALLEGRO_COLOR blue = al_map_rgba_f(0.1, 0.2, 1, 1);
ALLEGRO_COLOR purple = al_map_rgba_f(0.3, 0.1, 0.2, 1);
int x, y, w, h, as, de, xpos, ypos;
unsigned int index;
int target_w, target_h;
ALLEGRO_USTR_INFO info, sub_info;
const ALLEGRO_USTR *u;
ALLEGRO_USTR *tulip = al_ustr_new("Tulip");
ALLEGRO_USTR *dimension_text = al_ustr_new("Tulip");
ALLEGRO_USTR *vertical_text = al_ustr_new("Rose.");
al_clear_to_color(white);
al_hold_bitmap_drawing(true);
al_draw_textf(ex.f1, black, 50, 20, 0, "Tulip (kerning)");
al_draw_textf(ex.f2, black, 50, 80, 0, "Tulip (no kerning)");
x = 50;
y = 140;
for (index = 0; index < al_ustr_length(dimension_text); index ++) {
int cp = ustr_at(dimension_text, index);
int bbx, bby, bbw, bbh;
al_get_glyph_dimensions(ex.f2, cp, &bbx, &bby, &bbw, &bbh);
al_draw_rectangle(x + bbx + 0.5, y + bby + 0.5, x + bbx + bbw - 0.5, y + bby + bbh - 0.5, blue, 1);
al_draw_rectangle(x + 0.5, y + 0.5, x + bbx + bbw - 0.5, y + bby + bbh - 0.5, green, 1);
al_draw_glyph(ex.f2, purple, x, y, cp);
x += al_get_glyph_advance(ex.f2, cp, ALLEGRO_NO_KERNING);
}
al_draw_line(50.5, y+0.5, x+0.5, y+0.5, red, 1);
al_draw_textf(ex.f2, black, x + 10, y, 0, "(dimensions)");
al_draw_textf(ex.f3, black, 50, 200, 0, "This font has a size of 12 pixels, "
"the one above has 48 pixels.");
al_hold_bitmap_drawing(false);
al_hold_bitmap_drawing(true);
al_draw_textf(ex.f3, red, 50, 220, 0, "The color can simply be changed.🐊← fallback glyph");
al_hold_bitmap_drawing(false);
al_hold_bitmap_drawing(true);
al_draw_textf(ex.f3, green, 50, 240, 0, "Some unicode symbols:");
al_draw_textf(ex.f3, green, 50, 260, 0, "%s", get_string("symbols1"));
al_draw_textf(ex.f3, green, 50, 280, 0, "%s", get_string("symbols2"));
al_draw_textf(ex.f3, green, 50, 300, 0, "%s", get_string("symbols3"));
#define OFF(x) al_ustr_offset(u, x)
#define SUB(x, y) al_ref_ustr(&sub_info, u, OFF(x), OFF(y))
u = al_ref_cstr(&info, get_string("substr1"));
al_draw_ustr(ex.f3, green, 50, 320, 0, SUB(0, 6));
u = al_ref_cstr(&info, get_string("substr2"));
al_draw_ustr(ex.f3, green, 50, 340, 0, SUB(7, 11));
u = al_ref_cstr(&info, get_string("substr3"));
al_draw_ustr(ex.f3, green, 50, 360, 0, SUB(4, 11));
u = al_ref_cstr(&info, get_string("substr4"));
al_draw_ustr(ex.f3, green, 50, 380, 0, SUB(0, 11));
al_draw_textf(ex.f5, black, 50, 395, 0, "forced monochrome");
/* Glyph rendering tests. */
al_draw_textf(ex.f3, red, 50, 410, 0, "Glyph adv Tu: %d, draw: ",
al_get_glyph_advance(ex.f3, 'T', 'u'));
x = 50;
y = 425;
for (index = 0; index < al_ustr_length(tulip); index ++) {
int cp = ustr_at(tulip, index);
/* Use al_get_glyph_advance for the stride, with no kerning. */
al_draw_glyph(ex.f3, red, x, y, cp);
x += al_get_glyph_advance(ex.f3, cp, ALLEGRO_NO_KERNING);
}
x = 50;
y = 440;
/* First draw a red string using al_draw_text, that should be hidden
* completely by the same text drawing in green per glyph
* using al_draw_glyph and al_get_glyph_advance below. */
al_draw_ustr(ex.f3, red, x, y, 0, tulip);
for (index = 0; index < al_ustr_length(tulip); index ++) {
int cp = ustr_at(tulip, index);
int ncp = (index < (al_ustr_length(tulip) - 1)) ?
ustr_at(tulip, index + 1) : ALLEGRO_NO_KERNING;
/* Use al_get_glyph_advance for the stride and apply kerning. */
al_draw_glyph(ex.f3, green, x, y, cp);
x += al_get_glyph_advance(ex.f3, cp, ncp);
}
x = 50;
y = 466;
al_draw_ustr(ex.f3, red, x, y, 0, tulip);
for (index = 0; index < al_ustr_length(tulip); index ++) {
int cp = ustr_at(tulip, index);
int bbx, bby, bbw, bbh;
al_get_glyph_dimensions(ex.f3, cp, &bbx, &bby, &bbw, &bbh);
al_draw_glyph(ex.f3, blue, x, y, cp);
x += bbx + bbw;
}
x = 10;
y = 30;
for (index = 0; index < al_ustr_length(vertical_text); index ++) {
int bbx, bby, bbw, bbh;
int cp = ustr_at(vertical_text, index);
/* Use al_get_glyph_dimensions for the height to apply. */
al_get_glyph_dimensions(ex.f3, cp, &bbx, &bby, &bbw, &bbh);
al_draw_glyph(ex.f3, green, x, y, cp);
y += bby;
y += bbh;
}
x = 30;
y = 30;
for (index = 0; index < al_ustr_length(vertical_text); index ++) {
int bbx, bby, bbw, bbh;
int cp = ustr_at(vertical_text, index);
/* Use al_get_glyph_dimensions for the height to apply, here bby is
* omited for the wrong result. */
al_get_glyph_dimensions(ex.f3, cp, &bbx, &bby, &bbw, &bbh);
al_draw_glyph(ex.f3, red, x, y, cp);
y += bbh;
}
al_hold_bitmap_drawing(false);
target_w = al_get_bitmap_width(al_get_target_bitmap());
target_h = al_get_bitmap_height(al_get_target_bitmap());
xpos = target_w - 10;
ypos = target_h - 10;
al_get_text_dimensions(ex.f4, "Allegro", &x, &y, &w, &h);
as = al_get_font_ascent(ex.f4);
de = al_get_font_descent(ex.f4);
xpos -= w;
ypos -= h;
x += xpos;
y += ypos;
al_draw_rectangle(x, y, x + w - 0.5, y + h - 0.5, black, 0);
al_draw_line(x+0.5, y + as + 0.5, x + w - 0.5, y + as + 0.5, black, 0);
al_draw_line(x + 0.5, y + as + de + 0.5, x + w - 0.5, y + as + de + 0.5, black, 0);
al_hold_bitmap_drawing(true);
al_draw_textf(ex.f4, blue, xpos, ypos, 0, "Allegro");
al_hold_bitmap_drawing(false);
al_hold_bitmap_drawing(true);
al_draw_textf(ex.f3, black, target_w, 0, ALLEGRO_ALIGN_RIGHT,
"%.1f FPS", ex.fps);
al_draw_textf(ex.f3, black, 0, 0, 0, "%s: %d unicode ranges", font_file,
ex.ranges_count);
al_hold_bitmap_drawing(false);
}
/* Generates a bitmap with transparent background and the logo text.
* The bitmap will have screen size. If 'bumpmap' is not NULL, it will
* contain another bitmap which is a white, blurred mask of the logo
* which we use for the flash effect.
*/
static ALLEGRO_BITMAP *generate_logo(char const *text,
char const *fontname,
int font_size,
float shadow_offset,
float blur_radius,
float blur_factor,
float light_red,
float light_green,
float light_blue,
ALLEGRO_BITMAP **bumpmap)
{
ALLEGRO_COLOR transparent = al_map_rgba_f(0, 0, 0, 0);
int xp, yp, w, h, i, j, x, y, br, bw, dw, dh;
ALLEGRO_COLOR c;
ALLEGRO_FONT *logofont;
ALLEGRO_STATE state;
ALLEGRO_BITMAP *blur, *light, *logo;
int left, right, top, bottom;
float cx, cy;
dw = al_get_bitmap_width(al_get_target_bitmap());
dh = al_get_bitmap_height(al_get_target_bitmap());
cx = dw * 0.5;
cy = dh * 0.5;
logofont = al_load_font(fontname, -font_size, 0);
al_get_text_dimensions(logofont, text, &xp, &yp, &w, &h);
al_store_state(&state, ALLEGRO_STATE_TARGET_BITMAP | ALLEGRO_STATE_BLENDER);
/* Cheap blur effect to create a bump map. */
blur = al_create_bitmap(dw, dh);
al_set_target_bitmap(blur);
al_clear_to_color(transparent);
br = blur_radius;
bw = br * 2 + 1;
c = al_map_rgba_f(1, 1, 1, 1.0 / (bw * bw * blur_factor));
al_set_separate_blender(ALLEGRO_ADD, ALLEGRO_ALPHA, ALLEGRO_INVERSE_ALPHA,
ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_ONE);
for (i = -br; i <= br; i++) {
for (j = -br; j <= br; j++) {
al_draw_text(logofont, c,
cx - xp * 0.5 - w * 0.5 + i,
cy - yp * 0.5 - h * 0.5 + j, 0, text);
}
}
left = cx - xp * 0.5 - w * 0.5 - br + xp;
top = cy - yp * 0.5 - h * 0.5 - br + yp;
right = left + w + br * 2;
bottom = top + h + br * 2;
if (left < 0)
left = 0;
if (top < 0)
top = 0;
if (right > dw - 1)
right = dw - 1;
if (bottom > dh - 1)
bottom = dh - 1;
/* Cheap light effect. */
light = al_create_bitmap(dw, dh);
al_set_target_bitmap(light);
al_clear_to_color(transparent);
al_lock_bitmap(blur, ALLEGRO_PIXEL_FORMAT_ANY, ALLEGRO_LOCK_READONLY);
al_lock_bitmap_region(light, left, top,
1 + right - left, 1 + bottom - top,
ALLEGRO_PIXEL_FORMAT_ANY, ALLEGRO_LOCK_WRITEONLY);
for (y = top; y <= bottom; y++) {
for (x = left; x <= right; x++) {
float r1, g1, b1, a1;
float r2, g2, b2, a2;
float r, g, b, a;
float d;
ALLEGRO_COLOR c = al_get_pixel(blur, x, y);
ALLEGRO_COLOR c1 = al_get_pixel(blur, x - 1, y - 1);
ALLEGRO_COLOR c2 = al_get_pixel(blur, x + 1, y + 1);
al_unmap_rgba_f(c, &r, &g, &b, &a);
al_unmap_rgba_f(c1, &r1, &g1, &b1, &a1);
al_unmap_rgba_f(c2, &r2, &g2, &b2, &a2);
d = r2 - r1 + 0.5;
r = clamp(d * light_red);
g = clamp(d * light_green);
b = clamp(d * light_blue);
c = al_map_rgba_f(r, g, b, a);
al_put_pixel(x, y, c);
}
}
al_unlock_bitmap(light);
al_unlock_bitmap(blur);
if (bumpmap)
*bumpmap = blur;
else
al_destroy_bitmap(blur);
/* Create final logo */
logo = al_create_bitmap(dw, dh);
al_set_target_bitmap(logo);
al_clear_to_color(transparent);
/* Draw a shadow. */
c = al_map_rgba_f(0, 0, 0, 0.5 / 9);
al_set_separate_blender(ALLEGRO_ADD, ALLEGRO_ALPHA, ALLEGRO_INVERSE_ALPHA,
ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_ONE);
for (i = -1; i <= 1; i++)
for (j = -1; j <= 1; j++)
al_draw_text(logofont, c,
cx - xp * 0.5 - w * 0.5 + shadow_offset + i,
cy - yp * 0.5 - h * 0.5 + shadow_offset + j,
0, text);
/* Then draw the lit text we made before on top. */
al_set_separate_blender(ALLEGRO_ADD, ALLEGRO_ALPHA, ALLEGRO_INVERSE_ALPHA,
ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_INVERSE_ALPHA);
al_draw_bitmap(light, 0, 0, 0);
al_destroy_bitmap(light);
al_restore_state(&state);
al_destroy_font(logofont);
return logo;
}
static void render(void)
{
ALLEGRO_COLOR white = al_map_rgba_f(1, 1, 1, 1);
ALLEGRO_COLOR black = al_map_rgba_f(0, 0, 0, 1);
ALLEGRO_COLOR red = al_map_rgba_f(1, 0, 0, 1);
ALLEGRO_COLOR green = al_map_rgba_f(0, 0.5, 0, 1);
ALLEGRO_COLOR blue = al_map_rgba_f(0.1, 0.2, 1, 1);
int x, y, w, h, as, de, xpos, ypos;
int target_w, target_h;
ALLEGRO_USTR_INFO info, sub_info;
const ALLEGRO_USTR *u;
al_clear_to_color(white);
al_hold_bitmap_drawing(true);
al_draw_textf(ex.f1, black, 50, 50, 0, "Tulip (kerning)");
al_draw_textf(ex.f2, black, 50, 100, 0, "Tulip (no kerning)");
al_draw_textf(ex.f3, black, 50, 200, 0, "This font has a size of 12 pixels, "
"the one above has 48 pixels.");
al_hold_bitmap_drawing(false);
al_hold_bitmap_drawing(true);
al_draw_textf(ex.f3, red, 50, 220, 0, "The color can simply be changed.");
al_hold_bitmap_drawing(false);
al_hold_bitmap_drawing(true);
al_draw_textf(ex.f3, green, 50, 240, 0, "Some unicode symbols:");
al_draw_textf(ex.f3, green, 50, 260, 0, "%s", get_string("symbols1"));
al_draw_textf(ex.f3, green, 50, 280, 0, "%s", get_string("symbols2"));
al_draw_textf(ex.f3, green, 50, 300, 0, "%s", get_string("symbols3"));
#define OFF(x) al_ustr_offset(u, x)
#define SUB(x, y) al_ref_ustr(&sub_info, u, OFF(x), OFF(y))
u = al_ref_cstr(&info, get_string("substr1"));
al_draw_ustr(ex.f3, green, 50, 320, 0, SUB(0, 6));
u = al_ref_cstr(&info, get_string("substr2"));
al_draw_ustr(ex.f3, green, 50, 340, 0, SUB(7, 11));
u = al_ref_cstr(&info, get_string("substr3"));
al_draw_ustr(ex.f3, green, 50, 360, 0, SUB(4, 11));
u = al_ref_cstr(&info, get_string("substr4"));
al_draw_ustr(ex.f3, green, 50, 380, 0, SUB(0, 11));
al_draw_textf(ex.f5, black, 50, 420, 0, "forced monochrome");
al_hold_bitmap_drawing(false);
target_w = al_get_bitmap_width(al_get_target_bitmap());
target_h = al_get_bitmap_height(al_get_target_bitmap());
xpos = target_w - 10;
ypos = target_h - 10;
al_get_text_dimensions(ex.f4, "Allegro", &x, &y, &w, &h);
as = al_get_font_ascent(ex.f4);
de = al_get_font_descent(ex.f4);
xpos -= w;
ypos -= h;
x += xpos;
y += ypos;
al_draw_rectangle(x, y, x + w, y + h, black, 0);
al_draw_line(x, y + as, x + w, y + as, black, 0);
al_draw_line(x, y + as + de, x + w, y + as + de, black, 0);
al_hold_bitmap_drawing(true);
al_draw_textf(ex.f4, blue, xpos, ypos, 0, "Allegro");
al_hold_bitmap_drawing(false);
al_hold_bitmap_drawing(true);
al_draw_textf(ex.f3, black, target_w, 0, ALLEGRO_ALIGN_RIGHT,
"%.1f FPS", ex.fps);
al_hold_bitmap_drawing(false);
}
/**
Retrieves the actual dimensions of text.
@param text text.
@return dimensions.
*/
Rect<int> getDimensions(const std::string &text) const {
int x, y, w, h;
al_get_text_dimensions(get(), text.c_str(), &x, &y, &w, &h);
return makeRect(makePoint(x, y), makeSize(w, h));
}
/**
Retrieves the actual dimensions of text.
@param text text.
@return dimensions.
*/
Rect<int> getDimensions(const char *text) const {
int x, y, w, h;
al_get_text_dimensions(get(), text, &x, &y, &w, &h);
return makeRect(makePoint(x, y), makeSize(w, h));
}
