No OneTemporary
Actions

Authored By

Unknown

Size

20 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/util/allegro/bitmap.h b/util/allegro/bitmap.h
	index 93df4d14..97220f31 100644
	--- a/util/allegro/bitmap.h
	+++ b/util/allegro/bitmap.h
	@@ -1,19 +1,21 @@
	+#include <allegro.h>
	+
	#ifdef _WIN32
	#define BITMAP dummyBITMAP
	#include <windows.h>
	#undef BITMAP
	#endif

	struct BITMAP;

	struct BitmapData{
	inline BITMAP * getBitmap() const {
	return bitmap;
	}

	inline void setBitmap(BITMAP * b) {
	bitmap = b;
	}

	BITMAP * bitmap;
	};
	diff --git a/util/bitmap.h b/util/bitmap.h
	index 885f206f..19684f13 100644
	--- a/util/bitmap.h
	+++ b/util/bitmap.h
	@@ -1,299 +1,298 @@
	/* if you include this file then it must be the first line in file (after any
	* #ifdef's of course. windows will complain loudly if <windows.h> ends up being
	* included before allegro.h and this file fixes things so the order is correct.
	*/
	#ifndef _paintown_bitmap_h_
	#define _paintown_bitmap_h_

	-#include <string>
	-#include <vector>
	-
	-#include <iostream>
	-
	#ifdef USE_ALLEGRO
	#include "allegro/bitmap.h"
	#endif
	#ifdef USE_SDL
	#include "sdl/bitmap.h"
	#endif

	+#include <string>
	+#include <vector>
	+#include <iostream>
	+
	class Bitmap{
	private:
	static Bitmap * Screen;
	public:

	static int SCALE_X;
	static int SCALE_Y;

	/* default constructor makes 10x10 bitmap */
	Bitmap();
	Bitmap( int x, int y );
	Bitmap( const char * load_file );
	Bitmap( const std::string & load_file );
	Bitmap( const char * load_file, int sx, int sy );
	Bitmap( const char * load_file, int sx, int sy, double accuracy );

	/* 4/24/2010: remove this at some point */
	#ifdef USE_ALLEGRO
	explicit Bitmap( BITMAP * who, bool deep_copy = false );
	#endif
	#ifdef USE_SDL
	explicit Bitmap(SDL_Surface * who, bool deep_copy = false );
	#endif
	Bitmap( const Bitmap & copy, bool deep_copy = false );
	Bitmap( const Bitmap & copy, int sx, int sy );
	Bitmap( const Bitmap & copy, int sx, int sy, double accuracy );
	Bitmap( const Bitmap & copy, int x, int y, int width, int height );
	virtual ~Bitmap();

	virtual void save( const std::string & str );

	Bitmap & operator=( const Bitmap & );

	virtual void load( const std::string & str );

	int getWidth() const;
	int getHeight() const;

	/*
	inline const int getWidth() const{
	return getBitmap()->w;
	}

	inline const int getHeight() const{
	return getBitmap()->h;
	}
	*/

	/*
	inline const int getWidth() const{
	return my_bitmap->w;
	}

	inline const int getHeight() const{
	return my_bitmap->h;
	}
	*/

	static Bitmap memoryPCX(unsigned char * const data, const int length, const bool mask = true);

	void detach();

	static void transBlender( int r, int g, int b, int a );
	static void multiplyBlender( int r, int g, int b, int a );
	static void dissolveBlender( int r, int g, int b, int a );
	static void addBlender( int r, int g, int b, int a );
	static void burnBlender( int r, int g, int b, int a );
	static void colorBlender( int r, int g, int b, int a );
	static void differenceBlender( int r, int g, int b, int a );
	static void dodgeBlender( int r, int g, int b, int a );
	static void hueBlender( int r, int g, int b, int a );
	static void luminanceBlender( int r, int g, int b, int a );
	static void invertBlender( int r, int g, int b, int a );
	static void screenBlender( int r, int g, int b, int a );
	static int setGraphicsMode( int mode, int width, int height );

	static void drawingMode( int type );

	void acquire();
	void release();

	void resize( const int width, const int height );

	void debugSelf() const;

	/* convert to a grey scale version */
	virtual Bitmap greyScale();

	virtual void triangle( int x1, int y1, int x2, int y2, int x3, int y3, int color ) const;
	virtual void ellipse( int x, int y, int rx, int ry, int color ) const;
	virtual void ellipseFill( int x, int y, int rx, int ry, int color ) const;

	virtual void light(int x, int y, int width, int height, int start_y, int focus_alpha, int edge_alpha, int focus_color, int edge_color) const;
	virtual void applyTrans(const int color);

	virtual void border( int min, int max, int color ) const;
	virtual void rectangle( int x1, int y1, int x2, int y2, int color ) const;
	virtual void rectangleFill( int x1, int y1, int x2, int y2, int color ) const;
	virtual void circleFill( int x, int y, int radius, int color ) const;
	virtual void circle( int x, int y, int radius, int color ) const;
	virtual void line( const int x1, const int y1, const int x2, const int y2, const int color ) const;

	virtual void floodfill( const int x, const int y, const int color ) const;
	virtual void horizontalLine( const int x1, const int y, const int x2, const int color ) const;
	virtual void hLine( const int x1, const int y, const int x2, const int color ) const;
	virtual void vLine( const int y1, const int x, const int y2, const int color ) const;
	virtual void polygon( const int * verts, const int nverts, const int color ) const;
	virtual void arc(const int x, const int y, const double ang1, const double ang2, const int radius, const int color ) const;

	virtual void draw(const int x, const int y, const Bitmap & where) const;
	virtual void draw(const int x, const int y, const int startWidth, const int startHeight, const int width, const int height, const Bitmap & where) const;
	virtual void drawCharacter( const int x, const int y, const int color, const int background, const Bitmap & where ) const;
	/* to draw lit use LitBitmap */
	// virtual void drawLit( const int x, const int y, const int level, const Bitmap & where ) const;
	virtual void drawHFlip(const int x, const int y, const Bitmap & where) const;
	virtual void drawHFlip(const int x, const int y, const int startWidth, const int startHeight, const int width, const int height, const Bitmap & where) const;
	virtual void drawVFlip( const int x, const int y, const Bitmap & where ) const;
	virtual void drawHVFlip( const int x, const int y, const Bitmap & where ) const;
	virtual void drawTrans( const int x, const int y, const Bitmap & where ) const;
	virtual void drawTransHFlip( const int x, const int y, const Bitmap & where ) const;
	virtual void drawTransVFlip( const int x, const int y, const Bitmap & where ) const;
	virtual void drawTransHVFlip( const int x, const int y, const Bitmap & where ) const;
	virtual void drawMask( const int x, const int y, const Bitmap & where );
	virtual void drawStretched( const int x, const int y, const int new_width, const int new_height, const Bitmap & who );
	virtual void drawRotate( const int x, const int y, const int angle, const Bitmap & where );
	virtual void drawPivot( const int centerX, const int centerY, const int x, const int y, const int angle, const Bitmap & where );
	virtual void drawPivot( const int centerX, const int centerY, const int x, const int y, const int angle, const double scale, const Bitmap & where );

	virtual void Stretch( const Bitmap & where ) const;
	virtual void Stretch( const Bitmap & where, const int sourceX, const int sourceY, const int sourceWidth, const int sourceHeight, const int destX, const int destY, const int destWidth, const int destHeight ) const;
	virtual void StretchBy2( const Bitmap & where );
	virtual void StretchBy4( const Bitmap & where );
	virtual void Blit( const std::string & xpath ) const;
	virtual void Blit( const Bitmap & where ) const;
	virtual void Blit( const int x, const int y, const Bitmap & where ) const;
	virtual void Blit( const int mx, const int my, const int wx, const int wy, const Bitmap & where ) const;
	virtual void Blit( const int mx, const int my, const int width, const int height, const int wx, const int wy, const Bitmap & where ) const;
	virtual void BlitMasked( const int mx, const int my, const int width, const int height, const int wx, const int wy, const Bitmap & where ) const;
	virtual void BlitToScreen() const;
	virtual void BlitAreaToScreen(const int upper_left_x, const int upper_left_y) const;
	virtual void BlitToScreen(const int upper_left_x, const int upper_left_y) const;
	virtual void BlitFromScreen(const int x, const int y) const;

	/* try to call Global::getScreenWidth/Height() instead of these directly */
	static int getScreenWidth();
	static int getScreenHeight();

	virtual void fill( int color ) const;

	inline void clear() const{
	this->fill( 0 );
	}

	inline void clearToMask() const{
	this->fill(MaskColor);
	}

	bool getError();

	inline const BitmapData & getData() const {
	return data;
	}

	inline BitmapData & getData(){
	return data;
	}

	virtual void readLine( std::vector< int > & vec, int y );
	int getPixel( const int x, const int y ) const;

	/* uses _putpixel16 underneath which ignores translucent behavior */
	void putPixel( int x, int y, int col ) const;
	/* respects the current trans mode */
	void putPixelNormal(int x, int y, int col) const;

	/*
	inline int getPixel( int x, int y ) const{
	if ( x >= 0 && x < my_bitmap->w && y >= 0 && y <= my_bitmap->h )
	return _getpixel16( my_bitmap, x, y );
	return -1;
	}

	inline void putPixel( int x, int y, int col ) const{
	if ( x >= 0 && x < my_bitmap->w && y >= 0 && y <= my_bitmap->h )
	_putpixel16( my_bitmap, x, y, col );
	}
	*/

	void setClipRect( int x1, int y1, int x2, int y2 ) const;

	inline const std::string & getPath() const{
	return path;
	}

	/* produce a temporary bitmap that is not guaranteed to be preserved
	* after your function returns. do not hold references to this bitmap
	* and if you make a temporary bitmap, do not call functions that
	* might also make temporary bitmaps.
	*/
	static Bitmap temporaryBitmap(int w, int h);

	/* call this method to delete all temporary bitmaps.
	* don't call this unless you know what you are doing
	*/
	static void cleanupTemporaryBitmaps();

	static double getScale();
	static int setGfxModeText();
	static int setGfxModeFullscreen( int x, int y );
	static int setGfxModeWindowed( int x, int y );

	static int makeColor( int r, int g, int b );
	static int darken( int color, double factor );
	static void hsvToRGB( float h, float s, float v, int * r, int * g, int * b );

	/*
	* Convert color values between the HSV and RGB color spaces. The RGB values
	* range from 0 to 255, hue is from 0 to 360, and saturation and value are
	* from 0 to 1.
	*/
	static void rgbToHSV(int r, int g, int b, float * h, float * s, float * v);

	/* convert cymk to rgb. values should be in the range 0-255 */
	static void cymkToRGB(int c, int y, int m, int k, int * r, int * g, int * b);

	static int getRed( int x );
	static int getBlue( int x );
	static int getGreen( int x );

	/* Add two RGB16 colors together
	* r = c1.r + c2.r
	* g = c1.g + c2.g
	* b = c1.b + c2.b
	*/
	static int addColor( int color1, int color2 );

	/*
	inline static int makeColor( int r, int g, int b ){
	return makecol16( r, g, b );
	}
	*/

	// static const int MaskColor = MASK_COLOR_16;
	static const int MaskColor;
	static const int MODE_TRANS;
	static const int MODE_SOLID;

	static const int SPRITE_NO_FLIP;
	static const int SPRITE_V_FLIP;
	static const int SPRITE_H_FLIP;

	static const int SPRITE_NORMAL;
	static const int SPRITE_LIT;
	static const int SPRITE_TRANS;

	protected:

	void releaseInternalBitmap();

	/*
	inline void setBitmap( BITMAP * bitmap ){
	if ( bitmap == NULL ){
	std::cout << "FATAL Setting null bitmap" << std::endl;
	}
	_my_bitmap = bitmap;
	}
	*/

	void internalLoadFile( const char * load_file );

	/* implementation specific data */
	BitmapData data;
	int * own;
	// bool own;
	bool error;
	std::string path;
	static Bitmap * temporary_bitmap;
	};

	#endif
	diff --git a/util/file-system.cpp b/util/file-system.cpp
	index 523f52d9..959150aa 100644
	--- a/util/file-system.cpp
	+++ b/util/file-system.cpp
	@@ -1,347 +1,352 @@
	#ifdef USE_ALLEGRO
	#include <allegro.h>
	+#ifdef _WIN32
	+#define BITMAP dummyBITMAP
	+#include <windows.h>
	+#undef BITMAP
	+#endif
	#endif
	#include "funcs.h"
	#include "file-system.h"
	#include "system.h"
	#include <dirent.h>
	#include <sstream>
	#include <exception>
	#include <string>
	#include <ostream>

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

	using namespace std;

	namespace Filesystem{

	Exception::Exception(const std::string & file):
	reason(file){
	}

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

	NotFound::NotFound(const std::string & file):
	Exception(file){
	}

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

	IllegalPath::IllegalPath(const std::string & file):
	Exception(file){
	}

	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(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));
	}
	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<string> getFiles(const AbsolutePath & dataPath, const string & find){
	#ifdef USE_ALLEGRO
	struct al_ffblk info;
	vector< string > files;

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

	return files;
	#else
	vector<string> files;
	return files;
	#endif
	}

	/* remove extra path separators (/) */
	static 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("No path given");
	}

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

	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(){
	}

	static const 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(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()));
	}

	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();
	}

	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()));
	}

	}

File Metadata

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

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions