X-Git-Url: https://git.sesse.net/?p=ccbs;a=blobdiff_plain;f=bigscreen%2Ffonts.cpp;h=b9a02c5aecf24e0f0be6111dd8e5f08b050dc888;hp=8ceb87193b6cce7c9eae0dd228a56e4f698c9f39;hb=HEAD;hpb=4fce9b9798f93820661191b3bbc049c8d849f0fc

diff --git a/bigscreen/fonts.cpp b/bigscreen/fonts.cpp
index 8ceb871..b9a02c5 100644
--- a/bigscreen/fonts.cpp
+++ b/bigscreen/fonts.cpp
@@ -1,49 +1,136 @@
+#include <cstdio>
 #include <vector>
 #include <stdexcept>
+#include <map>
+#include <string>
+#include <harfbuzz/hb.h>
+#include <harfbuzz/hb-ft.h>
+#include <harfbuzz/hb-glib.h>
+#include <harfbuzz/hb-icu.h>
+#include <pango/pango-context.h>
+#include <pango/pango-fontmap.h>
+#include <pango/pangoft2.h>
 #include "fonts.h"
 #include "resolution.h"
+#include "theme.h"
 
-std::vector<FT_Face> fonts;
+extern std::map<std::string, std::string> config;
+std::map<std::string, FT_Face> faces;
+
+std::vector<std::string> split(const std::string &str, char delim)
+{
+	std::vector<std::string> ret;
+	std::string s;
+	for (unsigned i = 0; i < str.size(); ++i) {
+		if (str[i] == delim) {
+			ret.push_back(s);
+			s.clear();
+		} else {
+			s.push_back(str[i]);
+		}
+	}
+	if (!s.empty()) {
+		ret.push_back(s);
+	}
+	return ret;
+}
 
 void init_freetype()
 {
 	FT_Library library;
-	FT_Face face;
 	if (FT_Init_FreeType(&library))
 		throw std::runtime_error("FreeType init failed.");
 
-	// Georgia
-	if (FT_New_Face(library, "/usr/share/fonts/truetype/msttcorefonts/Georgia.ttf", 0, &face))
-		throw std::runtime_error("Face opening failed.");
-	fonts.push_back(face);
+	// Preload all fonts.
+	for (std::map<std::string, std::string>::const_iterator it = config.begin();
+	     it != config.end();
+	     ++it) {
+		const std::string key = it->first;
+		if (key.size() <= 5 || key.substr(key.size() - 5) != ".font") {
+			continue;
+		}
 
-	// FreeSerif
-	if (FT_New_Face(library, "/usr/share/fonts/truetype/freefont/FreeSerif.ttf", 0, &face)) {
-		std::fprintf(stderr, "Warning: Couldn't open FreeSerif, some glyphs might not be available\n");
-	} else {
-		fonts.push_back(face);
-	}
-	
-	// Arial Unicode MS
-	if (FT_New_Face(library, "arialuni.ttf", 0, &face)) {
-		std::fprintf(stderr, "Warning: Couldn't open Arial Unicode MS, some glyphs might not be available\n");
-	} else {
-		fonts.push_back(face);
+		std::vector<std::string> font_list = split(it->second, ';');
+		for (unsigned i = 0; i < font_list.size(); ++i) {
+			if (faces.count(font_list[i])) {
+				// Already preloaded.
+				continue;
+			}
+
+			FT_Face face;
+			if (FT_New_Face(library, font_list[i].c_str(), 0, &face)) {
+				fprintf(stderr, "Warning: Couldn't open '%s', some glyphs might not be available\n", font_list[i].c_str());
+			} else {
+				faces[font_list[i]] = face;
+			}
+		}
 	}
 }
 
 // this should really be done somehow else :-)
-static unsigned screen_width = SCREEN_WIDTH, screen_height = SCREEN_HEIGHT;
+static unsigned screen_width, screen_height;
 void set_screen_size(unsigned width, unsigned height)
 {
 	screen_width = width;
 	screen_height = height;
 }
 
-unsigned my_draw_text(const widestring &str, unsigned char *buf, double size, int xpos, int ypos, int r, int g, int b)
+void render_glyph(FT_GlyphSlot slot, int glyphx, int glyphy, unsigned char *buf, int r, int g, int b, bool use_lcd)
 {
-	FT_GlyphSlot slot;
-	int x = 0;
+	FT_Bitmap *bm = &(slot->bitmap);
+	for (unsigned y = 0; y < bm->rows; y++) {
+		int xx;
+		int dsty = glyphy - slot->bitmap_top + y;
+		if (dsty < 0 || dsty > signed(screen_height-1)) continue;
+
+		unsigned char *dst = buf + dsty * screen_width*4 + (glyphx + slot->bitmap_left)*4;
+		unsigned char *src = bm->buffer + y * bm->pitch;
+		if (use_lcd) {
+			int width = (glyphx + slot->bitmap_left + bm->width/3 >= signed(screen_width)) ? ((screen_width-1) - glyphx - slot->bitmap_left) : bm->width/3;
+			for (xx = 0; xx < width; xx++) {
+				*dst = (*dst * (256-src[2]) + b * src[2]) >> 8;
+				++dst;
+				*dst = (*dst * (256-src[1]) + g * src[1]) >> 8;
+				++dst;
+				*dst = (*dst * (256-src[0]) + r * src[0]) >> 8;
+				++dst;
+				*dst++ = 0;
+
+				src += 3;
+			}
+		} else {
+			int width = (glyphx + slot->bitmap_left + bm->width >= signed(screen_width)) ? ((screen_width-1) - glyphx - slot->bitmap_left) : bm->width;
+			for (xx = 0; xx < width; xx++) {
+				*dst = (*dst * (256-*src) + b * *src) >> 8;
+				++dst;
+				*dst = (*dst * (256-*src) + g * *src) >> 8;
+				++dst;
+				*dst = (*dst * (256-*src) + r * *src) >> 8;
+				++dst;
+				*dst++ = 0;
+				++src;
+			}
+		}
+	}
+}
+
+unsigned my_draw_text(const widestring &str, unsigned char *buf, double size, const std::string &theme_element, int xpos, int ypos)
+{
+	int start_xpos = xpos;
+
+	int r = atoi(get_theme_config(theme_element, "red").c_str());
+	int g = atoi(get_theme_config(theme_element, "green").c_str());
+	int b = atoi(get_theme_config(theme_element, "blue").c_str());
+	bool use_lcd = atoi(get_theme_config("screen", "lcd").c_str());
+
+	// Find font faces.
+	std::vector<FT_Face> fonts;
+	std::vector<std::string> font_list = split(get_theme_config(theme_element, "font"), ';');
+	for (unsigned i = 0; i < font_list.size(); ++i) {
+		if (faces.count(font_list[i])) {
+			fonts.push_back(faces[font_list[i]]);
+		}
+	}
 	
 	for (std::vector<FT_Face>::const_iterator i = fonts.begin(); i != fonts.end(); ++i) {
 		if (FT_Set_Char_Size(*i, 0, unsigned(size * 64.0), 96 * screen_width/LOGICAL_SCREEN_WIDTH, 96 * screen_height/LOGICAL_SCREEN_HEIGHT))
@@ -54,78 +141,117 @@ unsigned my_draw_text(const widestring &str, unsigned char *buf, double size, in
 	xpos = xpos * screen_width / LOGICAL_SCREEN_WIDTH;
 	ypos = ypos * screen_height / LOGICAL_SCREEN_HEIGHT;
 
-	for (widestring::const_iterator i = str.begin(); i != str.end(); ++i) {
-		int glyph_index;
-		for (std::vector<FT_Face>::const_iterator j = fonts.begin(); j != fonts.end(); ++j) {
-			glyph_index = FT_Get_Char_Index(*j, *i);
-			if (glyph_index == 0)
-				continue;
+	// Itemize the text into parts that will be shaped and rendered separately.
+	PangoContext *context = pango_context_new();
+	PangoFontMap *fontmap = pango_ft2_font_map_new();
+	pango_context_set_font_map(context, fontmap);
+	PangoAttrList *attrs = pango_attr_list_new();
+	std::string utf8str = str.to_utf8();
+	GList *items = pango_itemize(context, utf8str.data(), 0, utf8str.size(), attrs, NULL);
+	for (GList *item_it = items; item_it != NULL; item_it = item_it->next) {
+		PangoItem *item = (PangoItem *)(item_it->data);
+		PangoAnalysis *analysis = &item->analysis;
 
-			if (FT_Load_Glyph(*j, glyph_index, FT_LOAD_RENDER))
-				throw std::runtime_error("Couldn't load glyph");
-			slot = (*j)->glyph;
-			break;
-		}
-		if (glyph_index == 0) {
-			std::fprintf(stderr, "Warning: Could not find a glyph in any font for U+%x, ignoring\n", *i);
-			continue;
-		}
+		// Try to shape and render it in each of the fonts in turn.
+		for (std::vector<FT_Face>::const_iterator face_it = fonts.begin(); face_it != fonts.end(); ++face_it) {
+			// The buffer seemingly needs to be created anew for each try.
+			hb_buffer_t *hbuf = hb_buffer_create();
+			hb_buffer_set_unicode_funcs(hbuf, hb_icu_get_unicode_funcs());
+			hb_direction_t dir = PANGO_GRAVITY_IS_VERTICAL(analysis->gravity) ? HB_DIRECTION_TTB : HB_DIRECTION_LTR;
+			if (analysis->level % 2)
+				dir = HB_DIRECTION_REVERSE(dir);
+			if (PANGO_GRAVITY_IS_IMPROPER (analysis->gravity))
+				dir = HB_DIRECTION_REVERSE(dir);
+
+			hb_buffer_set_direction(hbuf, dir);
+			hb_buffer_set_script(hbuf, hb_glib_script_to_script((GUnicodeScript)analysis->script));
+			hb_buffer_set_language(hbuf, hb_language_from_string(pango_language_to_string(analysis->language), -1));
+			hb_buffer_add_utf8(hbuf, utf8str.data(), utf8str.size(), item->offset, item->length);
+
+			// Font-specifics.
+			FT_Face face = *face_it;
+			hb_font_t *font = hb_ft_font_create(face, NULL);
+			hb_shape(font, hbuf, NULL, 0);
+			unsigned glyph_count;
+			hb_glyph_info_t *glyph_info = hb_buffer_get_glyph_infos(hbuf, &glyph_count);
+			hb_glyph_position_t *glyph_pos = hb_buffer_get_glyph_positions(hbuf, &glyph_count);
 
-		if (buf != NULL) {
-			int y;
-			FT_Bitmap *bm = &(slot->bitmap);
-			for (y = 0; y < bm->rows; y++) {
-				int xx;
-				int dsty = ypos - slot->bitmap_top + y;
-				if (dsty < 0 || dsty > signed(screen_height-1)) continue;
-
-				unsigned char *dst = buf + dsty * screen_width*4 + (x + xpos + slot->bitmap_left)*4;
-				unsigned char *src = bm->buffer + y * bm->width;
-
-				int width = (x + xpos + slot->bitmap_left + bm->width >= signed(screen_width)) ? ((screen_width-1) - x - xpos - slot->bitmap_left) : bm->width;
-				for (xx = 0; xx < width; xx++) {
-					*dst = (*dst * (256-*src) + b * *src) >> 8;
-					*dst++;
-					*dst = (*dst * (256-*src) + g * *src) >> 8;
-					*dst++;
-					*dst = (*dst * (256-*src) + r * *src) >> 8;
-					*dst++;
-					*dst++ = 0;
-					src++;
+			bool found_all = true;
+			for (unsigned i = 0; i < glyph_count; ++i) {
+				if (glyph_info[i].codepoint == 0) {
+					found_all = false;
 				}
+				break;
 			}
-		}
 
-		x += slot->advance.x >> 6;
+			if (!found_all) {
+				std::string utf8itemstr(&utf8str[item->offset], &utf8str[item->offset + item->length]);
+				if (face_it + 1 == fonts.end()) {
+					std::fprintf(stderr, "Warning: Could not find any font to render item '%s', rendering in last font anyway\n", utf8itemstr.c_str());
+				} else {
+					hb_font_destroy(font);
+					hb_buffer_destroy(hbuf);
+					continue;
+				}
+			}
+
+			for (unsigned i = 0; i < glyph_count; ++i) {
+				if (use_lcd) {
+					if (FT_Load_Glyph(face, glyph_info[i].codepoint, FT_LOAD_RENDER | FT_LOAD_TARGET_LCD))
+						throw std::runtime_error("Couldn't load glyph");
+				} else {
+					if (FT_Load_Glyph(face, glyph_info[i].codepoint, FT_LOAD_RENDER))
+						throw std::runtime_error("Couldn't load glyph");
+				}
+
+				int glyphx = xpos + glyph_pos[i].x_offset / 64;
+				int glyphy = ypos - glyph_pos[i].y_offset / 64;
+
+				if (buf != NULL) {
+					render_glyph(face->glyph, glyphx, glyphy, buf, r, g, b, use_lcd);
+				}
+
+				xpos += glyph_pos[i].x_advance / 64;
+				ypos -= glyph_pos[i].y_advance / 64;
+			}
+			hb_font_destroy(font);
+			hb_buffer_destroy(hbuf);
+			break;
+		}
+		pango_item_free(item);
 	}
+	g_list_free(items);
+	pango_attr_list_unref(attrs);
+	g_object_unref(fontmap);
+	g_object_unref(context);
 
-	return x * LOGICAL_SCREEN_WIDTH / screen_width;
+	return (xpos - start_xpos) * LOGICAL_SCREEN_WIDTH / screen_width;
 }
 
-void my_draw_text_deferred(std::vector<TextDefer> &td, const widestring &str, double size, int xpos, int ypos)
+void my_draw_text_deferred(std::vector<TextDefer> &td, const widestring &str, double size, const std::string &theme_element, const std::string &fresh_theme_element, int xpos, int ypos)
 {
 	TextDefer newtd;
 	newtd.str = str;
 	newtd.size = size;
 	newtd.xpos = xpos;
 	newtd.ypos = ypos;
+	newtd.theme_element = theme_element;
+	newtd.fresh_theme_element = fresh_theme_element;
 	td.push_back(newtd);
 }
 
 void draw_all_deferred_text(unsigned char *buf, std::vector<TextDefer> &current, std::vector<TextDefer> &old)
 {
 	for (unsigned i = 0; i < current.size(); ++i) {
-		int r, g, b;
+		std::string theme_element;
 		if (i < old.size() && current[i].str != old[i].str) {
 			// changed text
-			r = 255;
-			g = 0;
-			b = 0;
+			theme_element = current[i].fresh_theme_element;
 		} else {
-			r = g = b = 255;
+			theme_element = current[i].theme_element;
 		}	
 		
-		my_draw_text(current[i].str, buf, current[i].size, current[i].xpos, current[i].ypos, r, g, b);
+		my_draw_text(current[i].str, buf, current[i].size, theme_element, current[i].xpos, current[i].ypos);
 	}
 }