1

/* $Id$ */

     2

     3

#ifndef BLITTER_FACTORY_HPP

     4

#define BLITTER_FACTORY_HPP

     5

     6

#include "base.hpp"

     7

#include "../string.h"

     8

#include "../debug.h"

     9

#include <string>

    10

#include <map>

    11

    12

/**

    13

 * The base factory, keeping track of all blitters.

    14

 */

    15

class BlitterFactoryBase {

    16

private:

    17

	char *name;

    18

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

    19

    20

	static Blitters &GetBlitters()

    21

	{

    22

		static Blitters &s_blitters = *new Blitters();

    23

		return s_blitters;

    24

	}

    25

    26

	static Blitter **GetActiveBlitter()

    27

	{

    28

		static Blitter *s_blitter = NULL;

    29

		return &s_blitter;

    30

	}

    31

    32

protected:

    33

	/**

    34

	 * Register a blitter internally, based on his name.

    35

	 * @param name the name of the blitter.

    36

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

    37

	 */

    38

	void RegisterBlitter(const char *name)

    39

	{

    40

		/* Don't register nameless Blitters */

    41

		if (name == NULL) return;

    42

    43

		this->name = strdup(name);

    44

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

    45

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

    46

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

    47

#endif /* !NDEBUG */

    48

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

    49

		assert(P.second);

    50

	}

    51

    52

public:

    53

	BlitterFactoryBase() :

    54

		name(NULL)

    55

	{}

    56

    57

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

    58

    59

	/**

    60

	 * Find the requested blitter and return his class.

    61

	 * @param name the blitter to select.

    62

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

    63

	 */

    64

	static Blitter *SelectBlitter(const char *name)

    65

	{

    66

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

    67

    68

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

    69

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

    70

    71

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

    72

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

    73

			BlitterFactoryBase *b = (*it).second;

    74

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

    75

				Blitter *newb = b->CreateInstance();

    76

				delete *GetActiveBlitter();

    77

				*GetActiveBlitter() = newb;

    78

    79

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

    80

				return newb;

    81

			}

    82

		}

    83

		return NULL;

    84

	}

    85

    86

	/**

    87

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

    88

	 */

    89

	static Blitter *GetCurrentBlitter()

    90

	{

    91

		return *GetActiveBlitter();

    92

	}

    93

    94

    95

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

    96

	{

    97

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

    98

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

    99

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

   100

			BlitterFactoryBase *b = (*it).second;

   101

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

   102

		}

   103

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

   104

   105

		return p;

   106

	}

   107

   108

	/**

   109

	 * Get a nice description of the blitter-class.

   110

	 */

   111

	virtual const char *GetDescription() = 0;

   112

   113

	/**

   114

	 * Create an instance of this Blitter-class.

   115

	 */

   116

	virtual Blitter *CreateInstance() = 0;

   117

};

   118

   119

/**

   120

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

   121

 */

   122

template <class T>

   123

class BlitterFactory: public BlitterFactoryBase {

   124

public:

   125

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

   126

   127

	/**

   128

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

   129

	 */

   130

	const char *GetName();

   131

};

   132

   133

#endif /* BLITTER_FACTORY_HPP */