X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=bigscreen%2Ffonts.cpp;h=4b0f3c85541de609f435f7243a740413cb25b49b;hb=cb9749b300678e08c05bed4288ac200a13811b70;hp=aa61303b61a997223eaf6139a09845422bd2b58a;hpb=1f0419e8b9ad6225c901fdc9b272727547c08165;p=ccbs

diff --git a/bigscreen/fonts.cpp b/bigscreen/fonts.cpp
index aa61303..4b0f3c8 100644
--- a/bigscreen/fonts.cpp
+++ b/bigscreen/fonts.cpp
@@ -1,89 +1,164 @@
+#include <cstdio>
 #include <vector>
 #include <stdexcept>
+#include <map>
+#include <string>
 #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;
+		}
+
+		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;
+			}
 
-	// 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);
+			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;
+			}
+		}
 	}
-	
-	// 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);
+}
+
+void get_glyph(const std::vector<FT_Face> &fonts, wchar_t ch, FT_Face *face, int *glyph_index)
+{
+	for (std::vector<FT_Face>::const_iterator i = fonts.begin(); i != fonts.end(); ++i) {
+		*glyph_index = FT_Get_Char_Index(*i, ch);
+		if (*glyph_index == 0)
+			continue;
+		*face = *i;
+		return;
 	}
 }
 
-unsigned my_draw_text(const widestring &str, unsigned char *buf, double size, int xpos, int ypos, int r, int g, int b)
+// this should really be done somehow else :-)
+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, const std::string &theme_element, int xpos, int ypos)
 {
-	FT_GlyphSlot slot;
 	int x = 0;
+
+	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))
+		if (FT_Set_Char_Size(*i, 0, unsigned(size * 64.0), 96 * screen_width/LOGICAL_SCREEN_WIDTH, 96 * screen_height/LOGICAL_SCREEN_HEIGHT))
 			throw std::runtime_error("Couldn't set font size");
 	}
 
 	// whoop :-P
-	xpos = xpos * SCREEN_WIDTH / LOGICAL_SCREEN_WIDTH;
-	ypos = ypos * SCREEN_HEIGHT / LOGICAL_SCREEN_HEIGHT;
+	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) {
+		FT_Face face;
 		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;
-
-			if (FT_Load_Glyph(*j, glyph_index, FT_LOAD_RENDER))
-				throw std::runtime_error("Couldn't load glyph");
-			slot = (*j)->glyph;
-			break;
-		}
+		get_glyph(fonts, *i, &face, &glyph_index);
 		if (glyph_index == 0) {
-			std::fprintf(stderr, "Warning: Could not find a glyph in any font for U+%x, ignoring\n", *i);
+			std::fprintf(stderr, "Warning: Could not find a glyph in any font for U+%04x, ignoring\n", *i);
 			continue;
 		}
 
+		if (use_lcd) {
+			if (FT_Load_Glyph(face, glyph_index, FT_LOAD_RENDER | FT_LOAD_TARGET_LCD))
+				throw std::runtime_error("Couldn't load glyph");
+		} else {
+			if (FT_Load_Glyph(face, glyph_index, FT_LOAD_RENDER))
+				throw std::runtime_error("Couldn't load glyph");
+		}
+
+		FT_GlyphSlot slot = face->glyph;
 		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 > (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 >= 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++;
+				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->pitch;
+				if (use_lcd) {
+					int width = (x + xpos + slot->bitmap_left + bm->width/3 >= signed(screen_width)) ? ((screen_width-1) - x - xpos - 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 = (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;
+					}
 				}
 			}
 		}
@@ -91,33 +166,33 @@ unsigned my_draw_text(const widestring &str, unsigned char *buf, double size, in
 		x += slot->advance.x >> 6;
 	}
 
-	return x * LOGICAL_SCREEN_WIDTH / SCREEN_WIDTH;
+	return x * 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);
 	}
 }