No OneTemporary
Actions

Authored By

Unknown

Size

30 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/util/file-system.cpp b/util/file-system.cpp
	index 5e76cef2..23a53b3e 100644
	--- a/util/file-system.cpp
	+++ b/util/file-system.cpp
	@@ -1,424 +1,454 @@
	#ifdef USE_ALLEGRO
	#include <allegro.h>

	/* FIXME: replace with <winalleg.h> */
	#ifdef _WIN32
	#define BITMAP dummyBITMAP
	#include <windows.h>
	#undef BITMAP
	#endif

	#endif
	#include "funcs.h"
	#include "file-system.h"
	#include "system.h"
	#include "globals.h"
	#include <dirent.h>
	#include <sstream>
	#include <exception>
	#include <string>
	#include <ostream>

	#ifndef USE_ALLEGRO
	/* some sfl symbols conflict with allegro */
	#include "sfl/sfl.h"
	#include "sfl/sfldir.h"
	#endif

	#ifdef _WIN32
	#define _WIN32_IE 0x400
	#include <shlobj.h>
	#endif

	using namespace std;

	namespace Filesystem{

	Exception::Exception(const std::string & where, int line, const std::string & file):
	Exc::Base(where, line),
	reason(file){
	}

	Exception::Exception(const std::string & where, int line, const Exc::Base & nested, const std::string & file):
	Exc::Base(where, line, nested),
	reason(file){
	}

	Exception::Exception(const Exception & copy):
	Exc::Base(copy),
	reason(copy.reason){
	}

	Exception::~Exception() throw (){
	}

	const std::string Exception::getReason() const {
	return reason;
	}

	NotFound::NotFound(const std::string & where, int line, const std::string & file):
	Exception(where, line, file + string(" was not found")){
	}

	NotFound::NotFound(const std::string & where, int line, const Exc::Base & nested, const std::string & file):
	Exception(where, line, nested, file + string(" was not found")){
	}

	NotFound::NotFound(const NotFound & copy):
	Exception(copy){
	}

	NotFound::~NotFound() throw (){
	}

	IllegalPath::IllegalPath(const std::string & where, int line, const std::string & file):
	Exception(where, line, file){
	}

	IllegalPath::IllegalPath(const std::string & where, int line, const Exc::Base & nested, const std::string & file):
	Exception(where, line, nested, file){
	}

	IllegalPath::IllegalPath(const IllegalPath & copy):
	Exception(copy){
	}

	IllegalPath::~IllegalPath() throw(){
	}

	#ifdef _WIN32
	AbsolutePath userDirectory(){
	ostringstream str;
	char path[MAX_PATH];
	SHGetSpecialFolderPathA(0, path, CSIDL_APPDATA, false);
	str << path << "/paintown/";
	return AbsolutePath(str.str());
	}

	AbsolutePath configFile(){
	ostringstream str;
	char path[MAX_PATH];
	SHGetSpecialFolderPathA(0, path, CSIDL_APPDATA, false);
	str << path << "/paintown_configuration.txt";
	return AbsolutePath(str.str());
	}
	#else
	AbsolutePath configFile(){
	ostringstream str;
	/* what if HOME isn't set? */
	str << getenv("HOME") << "/.paintownrc";
	return AbsolutePath(str.str());
	}

	AbsolutePath userDirectory(){
	ostringstream str;
	/* what if HOME isn't set? */
	str << getenv("HOME") << "/.paintown/";
	return AbsolutePath(str.str());
	}
	#endif

	static AbsolutePath lookup(const RelativePath path) throw (NotFound){
	/* first try the main data directory */
	AbsolutePath final = Util::getDataPath2().join(path);
	if (System::readable(final.path())){
	return final;
	}
	/* then try the user directory, like ~/.paintown */
	final = userDirectory().join(path);
	if (System::readable(final.path())){
	return final;
	}
	/* then just look in the cwd */
	if (System::readable(path.path())){
	return AbsolutePath(path.path());
	}

	ostringstream out;
	out << "Cannot find " << path.path() << ". I looked in '" << Util::getDataPath2().join(path).path() << "', '" << userDirectory().join(path).path() << "', and '" << path.path() << "'" << endl;

	throw NotFound(__FILE__, __LINE__, out.str());
	}

	static vector<AbsolutePath> findDirectoriesIn(const AbsolutePath & path){
	vector<AbsolutePath> dirs;
	DIR * dir = opendir(path.path().c_str());
	if (dir == NULL){
	return dirs;
	}

	struct dirent * entry = readdir(dir);
	while (entry != NULL){
	- string total = path.path() + "/" + entry->d_name;
	- if (System::isDirectory(total)){
	- dirs.push_back(AbsolutePath(total));
	+ if (string(entry->d_name) != "." && string(entry->d_name) != ".."){
	+ string total = path.path() + "/" + entry->d_name;
	+ if (System::isDirectory(total)){
	+ dirs.push_back(AbsolutePath(total));
	+ }
	}
	entry = readdir(dir);
	}

	closedir(dir);

	return dirs;
	}

	vector<AbsolutePath> findDirectories(const RelativePath & path){
	typedef vector<AbsolutePath> Paths;
	Paths dirs;

	Paths main_dirs = findDirectoriesIn(Util::getDataPath2().join(path));
	Paths user_dirs = findDirectoriesIn(userDirectory().join(path));
	Paths here_dirs = findDirectoriesIn(Filesystem::AbsolutePath(path.path()));

	dirs.insert(dirs.end(), main_dirs.begin(), main_dirs.end());
	dirs.insert(dirs.end(), user_dirs.begin(), user_dirs.end());
	dirs.insert(dirs.end(), here_dirs.begin(), here_dirs.end());

	return dirs;
	}

	vector<AbsolutePath> getFiles(const AbsolutePath & dataPath, const string & find, bool caseInsensitive){
	#ifdef USE_ALLEGRO
	struct al_ffblk info;
	vector<AbsolutePath> files;

	if ( al_findfirst( (dataPath.path() + find).c_str(), &info, FA_ALL ) != 0 ){
	return files;
	}
	- files.push_back(AbsolutePath(dataPath.path() + string(info.name)));
	+ files.push_back(AbsolutePath(dataPath.path() + "/" + string(info.name)));
	while ( al_findnext( &info ) == 0 ){
	- files.push_back(AbsolutePath(dataPath.path() + string(info.name)));
	+ files.push_back(AbsolutePath(dataPath.path() + "/" + string(info.name)));
	}
	al_findclose( &info );

	return files;
	#else
	vector<AbsolutePath> files;
	DIRST sflEntry;
	bool ok = open_dir(&sflEntry, dataPath.path().c_str());
	while (ok){
	if (file_matches(sflEntry.file_name, find.c_str())){
	- files.push_back(AbsolutePath(dataPath.path() + string(sflEntry.file_name)));
	+ files.push_back(AbsolutePath(dataPath.path() + "/" + string(sflEntry.file_name)));
	}
	ok = read_dir(&sflEntry);
	}
	close_dir(&sflEntry);
	// Global::debug(0) << "Warning: Filesystem::getFiles() is not implemented yet for SDL" << endl;
	return files;
	#endif
	}

	+template <class X>
	+static void append(vector<X> & destination, const vector<X> & source){
	+ for (typename vector<X>::const_iterator it = source.begin(); it != source.end(); it++){
	+ destination.push_back(*it);
	+ }
	+}
	+
	+static vector<AbsolutePath> getAllDirectories(const AbsolutePath & path){
	+ vector<AbsolutePath> all = findDirectoriesIn(path);
	+ vector<AbsolutePath> final;
	+ append(final, all);
	+ for (vector<AbsolutePath>::iterator it = all.begin(); it != all.end(); it++){
	+ vector<AbsolutePath> more = getAllDirectories(*it);
	+ append(final, more);
	+ }
	+ return final;
	+}
	+
	+vector<AbsolutePath> getFilesRecursive(const AbsolutePath & dataPath, const string & find, bool caseInsensitive){
	+ vector<AbsolutePath> directories = getAllDirectories(dataPath);
	+ vector<AbsolutePath> files;
	+ for (vector<AbsolutePath>::iterator it = directories.begin(); it != directories.end(); it++){
	+ vector<AbsolutePath> found = getFiles(*it, find, caseInsensitive);
	+ append(files, found);
	+ }
	+ return files;
	+}
	+
	/* remove extra path separators (/) */
	string sanitize(string path){
	size_t double_slash = path.find("//");
	while (double_slash != string::npos){
	path.erase(double_slash, 1);
	double_slash = path.find("//");
	}
	return path;
	}

	/*
	std::string find(const std::string path){
	if (path.length() == 0){
	throw NotFound("No path given");
	}
	if (path[0] == '/'){
	string str(path);
	str.erase(0, 1);
	string out = lookup(str);
	if (System::isDirectory(out)){
	return sanitize(out + "/");
	}
	return sanitize(out);
	}
	string out = lookup(path);
	if (System::isDirectory(out)){
	return sanitize(out + "/");
	}
	return sanitize(out);
	}
	*/

	AbsolutePath find(const RelativePath & path){
	if (path.isEmpty()){
	throw NotFound(__FILE__, __LINE__, "No path given");
	}

	AbsolutePath out = lookup(path);
	if (System::isDirectory(out.path())){
	return AbsolutePath(sanitize(out.path() + "/"));
	}
	return AbsolutePath(sanitize(out.path()));
	}

	bool exists(const RelativePath & path){
	try{
	AbsolutePath absolute = find(path);
	return true;
	} catch (const NotFound & found){
	return false;
	}
	}

	RelativePath cleanse(const AbsolutePath & path){
	string str = path.path();
	if (str.find(Util::getDataPath2().path()) == 0){
	str.erase(0, Util::getDataPath2().path().length());
	} else if (str.find(userDirectory().path()) == 0){
	str.erase(0, userDirectory().path().length());
	}
	return RelativePath(str);
	}

	static string dirname(string path){
	if (path.find("/") != string::npos \|\|
	path.find("\\") != string::npos){
	size_t rem = path.find_last_of("/");
	if (rem != string::npos){
	return path.substr(0, rem+1);
	}

	rem = path.find_last_of("\\");
	if (rem != string::npos){
	return path.substr(0, rem+1);
	}
	}

	return "";
	}

	std::string stripDir(const std::string & str){
	std::string temp = str;
	if (str.find( "/") != std::string::npos \|\| str.find( "\\") != std::string::npos){
	size_t rem = temp.find_last_of( "/" );
	if (rem != std::string::npos){
	return str.substr(rem+1,str.size());
	}
	rem = temp.find_last_of( "\\" );
	if( rem != std::string::npos ){
	return str.substr(rem+1,str.size());
	}
	}
	return str;
	}

	std::string removeExtension(const std::string & str){
	if (str.find(".") != std::string::npos){
	return str.substr(0, str.find_last_of("."));
	}
	return str;
	}

	const string & Path::path() const {
	return mypath;
	}

	bool Path::isEmpty() const {
	return mypath.empty();
	}

	Path::~Path(){
	}

	Path::Path(){
	}

	std::string invertSlashes(const string & str){
	string tempStr = str;
	if (tempStr.find('\\') != string::npos){
	for (int i = tempStr.size()-1; i>-1; --i){
	if (tempStr[i] == '\\'){
	tempStr[i] = '/';
	}
	}
	}

	return tempStr;
	}

	Path::Path(const std::string & path):
	mypath(sanitize(invertSlashes(path))){
	}

	Path::Path(const Path & path):
	mypath(sanitize(invertSlashes(path.path()))){
	}

	RelativePath::RelativePath(){
	}

	RelativePath::RelativePath(const std::string & path):
	Path(path){
	if (! path.empty() && path[0] == '/'){
	ostringstream out;
	out << "Relative path '" << path << "' cannot start with a /. Only absolute paths can start with /";
	throw IllegalPath(__FILE__, __LINE__, out.str());
	}
	}

	RelativePath::RelativePath(const RelativePath & path):
	Path(path){
	}

	RelativePath RelativePath::getDirectory() const {
	return RelativePath(dirname(path()));
	}

	RelativePath RelativePath::getFilename() const {
	return RelativePath(stripDir(path()));
	}

	bool RelativePath::operator<(const RelativePath & path) const {
	return this->path() < path.path();
	}

	bool RelativePath::operator==(const RelativePath & path) const {
	return this->path() == path.path();
	}

	RelativePath RelativePath::join(const RelativePath & him) const {
	return RelativePath(sanitize(path() + "/" + him.path()));
	}

	RelativePath & RelativePath::operator=(const RelativePath & copy){
	setPath(copy.path());
	return *this;
	}

	AbsolutePath::AbsolutePath(){
	}

	AbsolutePath::AbsolutePath(const std::string & path):
	Path(path){
	}

	AbsolutePath::AbsolutePath(const AbsolutePath & path):
	Path(path){
	}

	AbsolutePath & AbsolutePath::operator=(const AbsolutePath & copy){
	setPath(copy.path());
	return *this;
	}

	bool AbsolutePath::operator==(const AbsolutePath & path) const {
	return this->path() == path.path();
	}

	bool AbsolutePath::operator<(const AbsolutePath & path) const {
	return this->path() < path.path();
	}

	AbsolutePath AbsolutePath::getDirectory() const {
	return AbsolutePath(dirname(path()));
	}

	AbsolutePath AbsolutePath::getFilename() const {
	return AbsolutePath(stripDir(path()));
	}

	AbsolutePath AbsolutePath::join(const RelativePath & path) const {
	return AbsolutePath(sanitize(this->path() + "/" + path.path()));
	}

	}
	diff --git a/util/file-system.h b/util/file-system.h
	index 56abde90..daa59817 100644
	--- a/util/file-system.h
	+++ b/util/file-system.h
	@@ -1,151 +1,155 @@
	#ifndef _paintown_file_system_h
	#define _paintown_file_system_h

	#include "exceptions/exception.h"
	#include <string>
	#include <vector>

	namespace Filesystem{
	/* sorry for the crappy abbreviation, but can't collide with the
	* Exception class here
	*/
	namespace Exc = ::Exception;

	class Exception: public Exc::Base {
	public:
	Exception(const std::string & where, int line, const std::string & file);
	Exception(const std::string & where, int line, const Exc::Base & nested, const std::string & file);
	Exception(const Exception & copy);
	virtual ~Exception() throw ();

	protected:
	virtual const std::string getReason() const;

	virtual Exc::Base * copy() const {
	return new Exception(*this);
	}

	private:
	std::string reason;
	};

	class NotFound: public Exception {
	public:
	NotFound(const std::string & where, int line, const std::string & file);
	NotFound(const std::string & where, int line, const Exc::Base & nested, const std::string & file);
	virtual ~NotFound() throw();
	NotFound(const NotFound & copy);
	protected:
	virtual Exc::Base * copy() const {
	return new NotFound(*this);
	}
	};

	class IllegalPath: public Exception {
	public:
	IllegalPath(const std::string & where, int line, const std::string & file);
	IllegalPath(const std::string & where, int line, const Exc::Base & nested, const std::string & file);
	virtual ~IllegalPath() throw();
	IllegalPath(const IllegalPath & copy);
	protected:
	virtual Exc::Base * copy() const {
	return new IllegalPath(*this);
	}
	};

	class Path{
	public:
	const std::string & path() const;
	bool isEmpty() const;

	virtual ~Path();

	protected:
	Path();
	Path(const std::string & path);
	Path(const Path & path);

	virtual inline void setPath(const std::string & s){
	mypath = s;
	}

	std::string mypath;
	};

	/* relative path should not have the leading data directory on it, just
	* the path within the paintown system.
	*/
	class RelativePath: public Path {
	public:
	explicit RelativePath();
	explicit RelativePath(const std::string & path);
	RelativePath(const RelativePath & path);

	bool operator<(const RelativePath & path) const;

	virtual RelativePath getDirectory() const;
	virtual RelativePath getFilename() const;

	/* a/ + b/ = a/b/ */
	RelativePath join(const RelativePath & path) const;
	RelativePath & operator=(const RelativePath & copy);

	bool operator==(const RelativePath & path) const;
	};

	/* absolute paths should have the entire filesystem path on it */
	class AbsolutePath: public Path {
	public:
	explicit AbsolutePath();
	explicit AbsolutePath(const std::string & path);
	AbsolutePath(const AbsolutePath & path);
	AbsolutePath & operator=(const AbsolutePath & copy);

	bool operator<(const AbsolutePath & path) const;
	bool operator==(const AbsolutePath & path) const;

	virtual AbsolutePath getDirectory() const;
	virtual AbsolutePath getFilename() const;

	AbsolutePath join(const RelativePath & path) const;
	};

	/* given a relative path like sounds/arrow.png, prepend the proper
	* data path to it to give data/sounds/arrow.png
	*/
	AbsolutePath find(const RelativePath & path);

	/* whether the file exists at all */
	bool exists(const RelativePath & path);
	bool exists(const AbsolutePath & path);

	/* remove the data path from a string
	* data/sounds/arrow.png -> sounds/arrow.png
	*/
	RelativePath cleanse(const AbsolutePath & path);

	/* returns all the directories starting with the given path.
	* will look in the main data directory, the user directory, and
	* the current working directory.
	*/
	std::vector<AbsolutePath> findDirectories(const RelativePath & path);

	/* basename, just get the filename and remove the directory part */
	std::string stripDir(const std::string & str);

	/* remove extension. foo.txt -> foo */
	std::string removeExtension(const std::string & str);

	/* user specific directory to hold persistent data */
	AbsolutePath userDirectory();

	/* user specific path to store the configuration file */
	AbsolutePath configFile();

	+ /* search a directory for some files matching pattern `find' */
	std::vector<AbsolutePath> getFiles(const AbsolutePath & dataPath, const std::string & find, bool caseInsensitive = false);

	+ /* same as getFiles but search directories recursively */
	+ std::vector<AbsolutePath> getFilesRecursive(const AbsolutePath & dataPath, const std::string & find, bool caseInsensitive = false);
	+
	std::string invertSlashes(const std::string & str);
	std::string sanitize(std::string path);
	}

	#endif
	diff --git a/util/font.cpp b/util/font.cpp
	index 6ad7a2fd..de4ae83b 100644
	--- a/util/font.cpp
	+++ b/util/font.cpp
	@@ -1,302 +1,306 @@
	#ifdef USE_ALLEGRO
	/* for textout_* and whatnot */
	#include <allegro.h>
	#endif
	#include "bitmap.h"
	#include "font.h"
	#include "funcs.h"
	#include "init.h"
	#include "ftalleg.h"
	#include "factory/font_factory.h"
	#include <string.h>

	using namespace std;

	Font::Font(){
	}

	/* copy/pasted from network/message.cpp */
	static vector< string > wrapStrings( const string & left, const string & right, const Font & font, int max, vector< string > accum ){
	if ( left == "" ){
	return accum;
	}

	int length = font.textLength(left.c_str());

	if (length >= max){
	return wrapStrings( left.substr( 0, left.length() / 2 ), left.substr( left.length() / 2 ) + right, font, max, accum );
	} else if ( length >= max - font.textLength( "E" ) \|\| right == "" ){
	accum.push_back( left );
	return wrapStrings( right, "", font, max, accum );
	} else {
	return wrapStrings( left + right.substr( 0, 1 ), right.substr( 1 ), font, max, accum );
	}
	}

	void Font::printfWrapLine(int x, int & y, int color, const Bitmap & work, int maxWidth, const char * line) const {
	vector< string > all;
	all = wrapStrings(string(line), "", *this, maxWidth, all );
	for ( vector< string >::iterator str = all.begin(); str != all.end(); str++ ){
	printf(x, y, color, work, *str, 0);
	y += getHeight();
	}
	y += getHeight() / 2;
	}

	#if 0
	void Font::printfWrapLine2(int x, int & y, int color, const Bitmap & work, int maxWidth, const char * line) const {
	int height = getHeight();
	while (*line != '\0'){
	char tmp2[1024];
	int left = strlen(line);
	int min = 0;
	int max = left;
	int current = (min + max) / 2;
	strncpy(tmp2, line, current);
	tmp2[current] = '\0';
	bool done = false;
	while (!done){
	int length = textLength(tmp2);
	if (length >= maxWidth){
	max = current;
	current = (min + max) / 2;
	strncpy(tmp2, line, current);
	tmp2[current] = '\0';
	} else if (length < maxWidth && current < max){
	min = current;
	current = (min + max) / 2;
	if (current == max - 1){
	current = max;
	done = true;
	}
	strncpy(tmp2, line, current);
	tmp2[current] = '\0';
	} else {
	done = true;
	}
	}
	printf(x, y, color, work, string(tmp2), 0);
	y += height;

	line += current;
	}

	y += height / 2;
	}
	#endif

	void Font::printfWrap(int x, int y, int color, const Bitmap & work, int maxWidth, const std::string & str, int marker, ... ) const {
	char buf[4096];
	va_list ap;

	va_start(ap, marker);
	Util::limitPrintf(buf, sizeof(buf), str.c_str(), ap);
	va_end(ap);

	char * start = buf;
	char * end = strchr(start, '\n');
	while (end != NULL){
	char tmp[1024];
	unsigned int ender = end - start;
	if (ender >= sizeof(tmp) - 1){
	ender = sizeof(tmp) - 1;
	}

	strncpy(tmp, start, ender);
	tmp[ender] = '\0';
	printfWrapLine(x, y, color, work, maxWidth, tmp);

	start = end + 1;
	end = strchr(start, '\n');
	}
	printfWrapLine(x, y, color, work, maxWidth, start);
	}

	Font::~Font(){
	}

	#ifdef USE_ALLEGRO
	AllegroFont::AllegroFont( const FONT * const font ):
	font(font){
	}

	AllegroFont::AllegroFont( const AllegroFont & copy ):
	font( copy.getInternalFont() ){
	}

	AllegroFont::~AllegroFont(){
	}

	int AllegroFont::textLength( const char * text ) const{
	return text_length( getInternalFont(), text );
	}

	int AllegroFont::getHeight( const string & str ) const {
	return getHeight();
	}

	int AllegroFont::getHeight() const {
	return text_height( getInternalFont() );
	}

	void AllegroFont::setSize( const int x, const int y ){
	}

	int AllegroFont::getSizeX() const {
	return 0;
	}

	int AllegroFont::getSizeY() const {
	return 0;
	}

	void AllegroFont::printf( int x, int y, int xSize, int ySize, int color, const Bitmap & work, const string & str, int marker, ... ) const {
	char buf[512];
	va_list ap;

	va_start(ap, marker);
	Util::limitPrintf(buf, sizeof(buf), str.c_str(), ap);
	va_end(ap);

	textout_ex(work.getData().getBitmap(), getInternalFont(), buf, x, y, color, -1);
	}

	void AllegroFont::printf( int x, int y, int color, const Bitmap & work, const string & str, int marker, ... ) const {
	char buf[512];
	va_list ap;

	va_start(ap, marker);
	uvszprintf(buf, sizeof(buf), str.c_str(), ap);
	va_end(ap);

	textout_ex(work.getData().getBitmap(), getInternalFont(), buf, x, y, color, -1);
	}
	#endif

	const Font & Font::getDefaultFont(){
	// return getFont( "tmp/comic.ttf" );
	// return *FontFactory::getFont(Filesystem::RelativePath("bios"), 16, 16);
	return *FontFactory::getFont(Filesystem::RelativePath("fonts/arial.ttf"), 16, 16);
	}

	const Font & Font::getDefaultFont(int width, int height){
	return *FontFactory::getFont(Filesystem::RelativePath("fonts/arial.ttf"), width, height);
	}

	/* name should be the path of a .ttf file in the fonts/ directory.
	* something like 'arial.ttf'
	*/
	const Font & Font::getFont(const Filesystem::RelativePath & name, const int x, const int y){
	Font & font = *FontFactory::getFont(name, x, y);
	/* sanity check */
	if (font.getHeight("A") == 0){
	return getDefaultFont();
	}
	return font;
	}
	+
	+const Font & Font::getFont( const Filesystem::AbsolutePath & name, const int x, const int y){
	+ return *FontFactory::getFont(name, x, y);
	+}

	FreeTypeFont::FreeTypeFont(const Filesystem::AbsolutePath & str ):
	sizeX( 16 ),
	sizeY( 16 ),
	own(true){
	this->font = new ftalleg::freetype(str, getSizeX(), getSizeY() );
	}

	int FreeTypeFont::getHeight( const string & str ) const {
	return this->font->getHeight( str );
	}

	int FreeTypeFont::getHeight() const {
	return getHeight( "A" );
	}

	int FreeTypeFont::textLength( const char * text ) const {
	return this->font->getLength(string(text));
	}

	void FreeTypeFont::printf( int x, int y, int xSize, int ySize, int color, const Bitmap & work, const string & str, int marker, ... ) const {
	char buf[512];
	va_list ap;

	va_start(ap, marker);
	vsnprintf(buf, sizeof(buf), str.c_str(), ap);
	va_end(ap);

	int old_x = 0;
	int old_y = 0;
	this->font->getSize(&old_x, &old_y);

	this->font->setSize(xSize, ySize);

	this->font->render( x, y, color, work, ftalleg::freetype::ftLeft, string( buf ), 0 );

	this->font->setSize(old_x, old_y);

	}

	void FreeTypeFont::printf( int x, int y, int color, const Bitmap & work, const string & str, int marker, ... ) const {
	char buf[512];
	va_list ap;

	va_start(ap, marker);
	vsnprintf(buf, sizeof(buf), str.c_str(), ap);
	va_end(ap);

	this->font->render(x, y, color, work, ftalleg::freetype::ftLeft, string(buf), 0);
	}

	void FreeTypeFont::setSize( const int x, const int y ){
	this->sizeX = x;
	this->sizeY = y;
	this->font->setSize( this->sizeX, this->sizeY );
	}

	int FreeTypeFont::getSizeX() const {
	return this->sizeX;
	}

	int FreeTypeFont::getSizeY() const {
	return this->sizeY;
	}

	FreeTypeFont::~FreeTypeFont(){
	// cout << "Delete font " << this->font << endl;
	if (own){
	delete this->font;
	}
	}

	NullFont::NullFont(){
	}

	NullFont::~NullFont(){
	}

	void NullFont::setSize( const int x, const int y ){
	}

	int NullFont::getSizeX() const {
	return 0;
	}

	int NullFont::getSizeY() const {
	return 0;
	}

	int NullFont::textLength( const char * text ) const {
	return 0;
	}

	int NullFont::getHeight( const std::string & str ) const {
	return 0;
	}

	int NullFont::getHeight() const {
	return 0;
	}

	void NullFont::printf( int x, int y, int xSize, int ySize, int color, const Bitmap & work, const std::string & str, int marker, ... ) const {
	}

	void NullFont::printf( int x, int y, int color, const Bitmap & work, const std::string & str, int marker, ... ) const {
	}
	diff --git a/util/font.h b/util/font.h
	index f5119304..91cec75a 100644
	--- a/util/font.h
	+++ b/util/font.h
	@@ -1,119 +1,120 @@
	#ifndef _paintown_font_h
	#define _paintown_font_h

	#include <string>
	#include <vector>
	// #include "ftalleg.h"

	class Bitmap;
	struct FONT;
	namespace ftalleg{
	class freetype;
	}

	namespace Filesystem{
	class RelativePath;
	class AbsolutePath;
	}

	/* handle allegro fonts and true type fonts */
	class Font{
	public:
	Font();
	virtual ~Font();

	virtual void setSize( const int x, const int y ) = 0;
	virtual int getSizeX() const = 0;
	virtual int getSizeY() const = 0;

	virtual int textLength( const char * text ) const = 0;

	virtual int getHeight( const std::string & str ) const = 0;
	virtual int getHeight() const = 0;

	virtual void printf( int x, int y, int xSize, int ySize, int color, const Bitmap & work, const std::string & str, int marker, ... ) const = 0;
	virtual void printf( int x, int y, int color, const Bitmap & work, const std::string & str, int marker, ... ) const = 0;
	virtual void printfWrap( int x, int y, int color, const Bitmap & work, int maxWidth, const std::string & str, int marker, ... ) const;

	static const Font & getDefaultFont();
	static const Font & getDefaultFont(int width, int height);
	static const Font & getFont( const Filesystem::RelativePath & name, const int x = 32, const int y = 32 );
	+ static const Font & getFont( const Filesystem::AbsolutePath & name, const int x = 32, const int y = 32 );

	/* store all the freetype fonts forever */
	static std::vector< ftalleg::freetype * > cacheFreeType;
	protected:

	void printfWrapLine(int x, int & y, int color, const Bitmap & work, int maxWidth, const char * line) const;
	};

	class NullFont: public Font {
	public:
	NullFont();
	virtual ~NullFont();

	virtual void setSize( const int x, const int y );
	virtual int getSizeX() const;
	virtual int getSizeY() const;

	virtual int textLength( const char * text ) const;

	virtual int getHeight( const std::string & str ) const;
	virtual int getHeight() const;

	virtual void printf( int x, int y, int xSize, int ySize, int color, const Bitmap & work, const std::string & str, int marker, ... ) const;
	virtual void printf( int x, int y, int color, const Bitmap & work, const std::string & str, int marker, ... ) const;

	};

	#ifdef USE_ALLEGRO
	class AllegroFont: public Font {
	public:
	AllegroFont( const FONT * const font );
	AllegroFont( const AllegroFont & copy );
	virtual ~AllegroFont();

	virtual int getHeight() const;
	virtual int getHeight( const std::string & str ) const;
	virtual int textLength( const char * text ) const;

	virtual void printf( int x, int y, int color, const Bitmap & work, const std::string & str, int marker, ... ) const;
	virtual void printf( int x, int y, int xSize, int ySize, int color, const Bitmap & work, const std::string & str, int marker, ... ) const;

	virtual void setSize( const int x, const int y );
	virtual int getSizeX() const;
	virtual int getSizeY() const;

	private:
	inline const FONT * getInternalFont() const {
	return font;
	}

	const FONT * const font;
	};
	#endif

	class FreeTypeFont: public Font {
	public:
	FreeTypeFont(const Filesystem::AbsolutePath & filename);
	FreeTypeFont(const FreeTypeFont & copy);
	virtual ~FreeTypeFont();

	virtual int getHeight() const;
	virtual int getHeight( const std::string & str ) const;
	virtual int textLength( const char * text ) const;

	virtual void printf( int x, int y, int color, const Bitmap & work, const std::string & str, int marker, ... ) const;
	virtual void printf( int x, int y, int xSize, int ySize, int color, const Bitmap & work, const std::string & str, int marker, ... ) const;

	virtual void setSize( const int x, const int y );
	virtual int getSizeX() const;
	virtual int getSizeY() const;

	private:
	ftalleg::freetype * font;
	int sizeX;
	int sizeY;
	bool own;
	};

	#endif

File Metadata

Mime Type: text/x-diff
Expires: Thu, Jun 11, 12:06 PM (3 w, 4 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 68954
Default Alt Text: (30 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions