1

/* $Id$ */

     2

     3

/** @file factory.hpp Factory to 'query' all available blitters. */

     4

     5

#ifndef BLITTER_FACTORY_HPP

     6

#define BLITTER_FACTORY_HPP

     7

     8

#include "base.hpp"

     9

#include "../debug.h"

    10

#include "../string_func.h"

    11

#include <map>

    12

    13

/**

    14

 * The base factory, keeping track of all blitters.

    15

 */

    16

class BlitterFactoryBase {

    17

private:

    18

	const char *name;

    19

    20

	struct StringCompare {

    21

		bool operator () (const char *a, const char *b) const

    22

		{

    23

			return strcmp(a, b) < 0;

    24

		}

    25

	};

    26

    27

	typedef std::map<const char *, BlitterFactoryBase *, StringCompare> Blitters;

    28

    29

	static Blitters &GetBlitters()

    30

	{

    31

		static Blitters &s_blitters = *new Blitters();

    32

		return s_blitters;

    33

	}

    34

    35

	static Blitter **GetActiveBlitter()

    36

	{

    37

		static Blitter *s_blitter = NULL;

    38

		return &s_blitter;

    39

	}

    40

    41

protected:

    42

	/**

    43

	 * Register a blitter internally, based on his name.

    44

	 * @param name the name of the blitter.

    45

	 * @note an assert() will be trigger if 2 blitters with the same name try to register.

    46

	 */

    47

	void RegisterBlitter(const char *name)

    48

	{

    49

		/* Don't register nameless Blitters */

    50

		if (name == NULL) return;

    51

    52

		this->name = strdup(name);

    53

    54

		std::pair<Blitters::iterator, bool> P = GetBlitters().insert(Blitters::value_type(name, this));

    55

		assert(P.second);

    56

	}

    57

    58

public:

    59

	BlitterFactoryBase() :

    60

		name(NULL)

    61

	{}

    62

    63

	virtual ~BlitterFactoryBase()

    64

	{

    65

		if (this->name == NULL) return;

    66

		GetBlitters().erase(this->name);

    67

		if (GetBlitters().empty()) delete &GetBlitters();

    68

		free((void *)this->name);

    69

	}

    70

    71

	/**

    72

	 * Find the requested blitter and return his class.

    73

	 * @param name the blitter to select.

    74

	 * @post Sets the blitter so GetCurrentBlitter() returns it too.

    75

	 */

    76

	static Blitter *SelectBlitter(const char *name)

    77

	{

    78

		const char *default_blitter = "8bpp-optimized";

    79

    80

#if defined(__APPLE__)

    81

		/* MacOS X 10.5 removed 8bpp fullscreen support.

    82

		 * Because of this we will pick 32bpp by default */

    83

		if (MacOSVersionIsAtLeast(10, 5, 0)) {

    84

			default_blitter = "32bpp-anim";

    85

		}

    86

#endif /* defined(__APPLE__) */

    87

		if (GetBlitters().size() == 0) return NULL;

    88

		const char *bname = (StrEmpty(name)) ? default_blitter : name;

    89

    90

		Blitters::iterator it = GetBlitters().begin();

    91

		for (; it != GetBlitters().end(); it++) {

    92

			BlitterFactoryBase *b = (*it).second;

    93

			if (strcasecmp(bname, b->name) == 0) {

    94

				Blitter *newb = b->CreateInstance();

    95

				delete *GetActiveBlitter();

    96

				*GetActiveBlitter() = newb;

    97

    98

				DEBUG(driver, 1, "Successfully %s blitter '%s'",StrEmpty(name) ? "probed" : "loaded", bname);

    99

				return newb;

   100

			}

   101

		}

   102

		return NULL;

   103

	}

   104

   105

	/**

   106

	 * Get the current active blitter (always set by calling SelectBlitter).

   107

	 */

   108

	static Blitter *GetCurrentBlitter()

   109

	{

   110

		return *GetActiveBlitter();

   111

	}

   112

   113

   114

	static char *GetBlittersInfo(char *p, const char *last)

   115

	{

   116

		p += snprintf(p, last - p, "List of blitters:\n");

   117

		Blitters::iterator it = GetBlitters().begin();

   118

		for (; it != GetBlitters().end(); it++) {

   119

			BlitterFactoryBase *b = (*it).second;

   120

			p += snprintf(p, last - p, "%18s: %s\n", b->name, b->GetDescription());

   121

		}

   122

		p += snprintf(p, last - p, "\n");

   123

   124

		return p;

   125

	}

   126

   127

	/**

   128

	 * Get a nice description of the blitter-class.

   129

	 */

   130

	virtual const char *GetDescription() = 0;

   131

   132

	/**

   133

	 * Create an instance of this Blitter-class.

   134

	 */

   135

	virtual Blitter *CreateInstance() = 0;

   136

};

   137

   138

/**

   139

 * A template factory, so ->GetName() works correctly. This because else some compiler will complain.

   140

 */

   141

template <class T>

   142

class BlitterFactory: public BlitterFactoryBase {

   143

public:

   144

	BlitterFactory() { this->RegisterBlitter(((T *)this)->GetName()); }

   145

   146

	/**

   147

	 * Get the long, human readable, name for the Blitter-class.

   148

	 */

   149

	const char *GetName();

   150

};

   151

   152

extern char _ini_blitter[32];

   153

   154

#endif /* BLITTER_FACTORY_HPP */