1

/* $Id$ */

     2

     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 <string>

    12

#include <map>

    13

    14

/**

    15

 * The base factory, keeping track of all blitters.

    16

 */

    17

class BlitterFactoryBase {

    18

private:

    19

	char *name;

    20

	typedef std::map<std::string, BlitterFactoryBase *> Blitters;

    21

    22

	static Blitters &GetBlitters()

    23

	{

    24

		static Blitters &s_blitters = *new Blitters();

    25

		return s_blitters;

    26

	}

    27

    28

	static Blitter **GetActiveBlitter()

    29

	{

    30

		static Blitter *s_blitter = NULL;

    31

		return &s_blitter;

    32

	}

    33

    34

protected:

    35

	/**

    36

	 * Register a blitter internally, based on his name.

    37

	 * @param name the name of the blitter.

    38

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

    39

	 */

    40

	void RegisterBlitter(const char *name)

    41

	{

    42

		/* Don't register nameless Blitters */

    43

		if (name == NULL) return;

    44

    45

		this->name = strdup(name);

    46

#if !defined(NDEBUG) || defined(WITH_ASSERT)

    47

		/* NDEBUG disables asserts and gives a warning: unused variable 'P' */

    48

		std::pair<Blitters::iterator, bool> P =

    49

#endif /* !NDEBUG */

    50

		GetBlitters().insert(Blitters::value_type(name, this));

    51

		assert(P.second);

    52

	}

    53

    54

public:

    55

	BlitterFactoryBase() :

    56

		name(NULL)

    57

	{}

    58

    59

	virtual ~BlitterFactoryBase() { if (this->name != NULL) GetBlitters().erase(this->name); free(this->name); }

    60

    61

	/**

    62

	 * Find the requested blitter and return his class.

    63

	 * @param name the blitter to select.

    64

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

    65

	 */

    66

	static Blitter *SelectBlitter(const char *name)

    67

	{

    68

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

    69

    70

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

    71

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

    72

    73

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

    74

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

    75

			BlitterFactoryBase *b = (*it).second;

    76

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

    77

				Blitter *newb = b->CreateInstance();

    78

				delete *GetActiveBlitter();

    79

				*GetActiveBlitter() = newb;

    80

    81

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

    82

				return newb;

    83

			}

    84

		}

    85

		return NULL;

    86

	}

    87

    88

	/**

    89

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

    90

	 */

    91

	static Blitter *GetCurrentBlitter()

    92

	{

    93

		return *GetActiveBlitter();

    94

	}

    95

    96

    97

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

    98

	{

    99

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

   100

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

   101

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

   102

			BlitterFactoryBase *b = (*it).second;

   103

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

   104

		}

   105

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

   106

   107

		return p;

   108

	}

   109

   110

	/**

   111

	 * Get a nice description of the blitter-class.

   112

	 */

   113

	virtual const char *GetDescription() = 0;

   114

   115

	/**

   116

	 * Create an instance of this Blitter-class.

   117

	 */

   118

	virtual Blitter *CreateInstance() = 0;

   119

};

   120

   121

/**

   122

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

   123

 */

   124

template <class T>

   125

class BlitterFactory: public BlitterFactoryBase {

   126

public:

   127

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

   128

   129

	/**

   130

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

   131

	 */

   132

	const char *GetName();

   133

};

   134

   135

extern char _ini_blitter[32];

   136

   137

#endif /* BLITTER_FACTORY_HPP */