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

#if defined(WITH_COCOA)

    14

bool QZ_CanDisplay8bpp();

    15

#endif /* defined(WITH_COCOA) */

    16

    17

/**

    18

 * The base factory, keeping track of all blitters.

    19

 */

    20

class BlitterFactoryBase {

    21

private:

    22

	const char *name;

    23

    24

	struct StringCompare {

    25

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

    26

		{

    27

			return strcmp(a, b) < 0;

    28

		}

    29

	};

    30

    31

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

    32

    33

	static Blitters &GetBlitters()

    34

	{

    35

		static Blitters &s_blitters = *new Blitters();

    36

		return s_blitters;

    37

	}

    38

    39

	static Blitter **GetActiveBlitter()

    40

	{

    41

		static Blitter *s_blitter = NULL;

    42

		return &s_blitter;

    43

	}

    44

    45

protected:

    46

	/**

    47

	 * Register a blitter internally, based on his name.

    48

	 * @param name the name of the blitter.

    49

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

    50

	 */

    51

	void RegisterBlitter(const char *name)

    52

	{

    53

		/* Don't register nameless Blitters */

    54

		if (name == NULL) return;

    55

    56

		this->name = strdup(name);

    57

    58

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

    59

		assert(P.second);

    60

	}

    61

    62

public:

    63

	BlitterFactoryBase() :

    64

		name(NULL)

    65

	{}

    66

    67

	virtual ~BlitterFactoryBase()

    68

	{

    69

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

    70

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

    71

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

    72

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

    73

	}

    74

    75

	/**

    76

	 * Find the requested blitter and return his class.

    77

	 * @param name the blitter to select.

    78

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

    79

	 */

    80

	static Blitter *SelectBlitter(const char *name)

    81

	{

    82

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

    83

    84

#if defined(WITH_COCOA)

    85

		/* Some people reported lack of fullscreen support in 8 bpp mode.

    86

		 * While we prefer 8 bpp since it's faster, we will still have to test for support. */

    87

		if (!QZ_CanDisplay8bpp()) {

    88

			/* The main display can't go to 8 bpp fullscreen mode.

    89

			 * We will have to switch to 32 bpp by default. */

    90

			default_blitter = "32bpp-anim";

    91

		}

    92

#endif /* defined(WITH_COCOA) */

    93

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

    94

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

    95

    96

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

    97

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

    98

			BlitterFactoryBase *b = (*it).second;

    99

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

   100

				Blitter *newb = b->CreateInstance();

   101

				delete *GetActiveBlitter();

   102

				*GetActiveBlitter() = newb;

   103

   104

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

   105

				return newb;

   106

			}

   107

		}

   108

		return NULL;

   109

	}

   110

   111

	/**

   112

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

   113

	 */

   114

	static Blitter *GetCurrentBlitter()

   115

	{

   116

		return *GetActiveBlitter();

   117

	}

   118

   119

   120

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

   121

	{

   122

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

   123

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

   124

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

   125

			BlitterFactoryBase *b = (*it).second;

   126

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

   127

		}

   128

		p += seprintf(p, last, "\n");

   129

   130

		return p;

   131

	}

   132

   133

	/**

   134

	 * Get a nice description of the blitter-class.

   135

	 */

   136

	virtual const char *GetDescription() = 0;

   137

   138

	/**

   139

	 * Create an instance of this Blitter-class.

   140

	 */

   141

	virtual Blitter *CreateInstance() = 0;

   142

};

   143

   144

/**

   145

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

   146

 */

   147

template <class T>

   148

class BlitterFactory: public BlitterFactoryBase {

   149

public:

   150

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

   151

   152

	/**

   153

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

   154

	 */

   155

	const char *GetName();

   156

};

   157

   158

extern char _ini_blitter[32];

   159

   160

#endif /* BLITTER_FACTORY_HPP */