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

    47

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

    48

		assert(P.second);

    49

	}

    50

    51

public:

    52

	BlitterFactoryBase() :

    53

		name(NULL)

    54

	{}

    55

    56

	virtual ~BlitterFactoryBase()

    57

	{

    58

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

    59

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

    60

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

    61

		free(this->name);

    62

	}

    63

    64

	/**

    65

	 * Find the requested blitter and return his class.

    66

	 * @param name the blitter to select.

    67

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

    68

	 */

    69

	static Blitter *SelectBlitter(const char *name)

    70

	{

    71

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

    72

    80

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

    81

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

    82

    83

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

    84

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

    85

			BlitterFactoryBase *b = (*it).second;

    86

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

    87

				Blitter *newb = b->CreateInstance();

    88

				delete *GetActiveBlitter();

    89

				*GetActiveBlitter() = newb;

    90

    91

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

    92

				return newb;

    93

			}

    94

		}

    95

		return NULL;

    96

	}

    97

    98

	/**

    99

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

   100

	 */

   101

	static Blitter *GetCurrentBlitter()

   102

	{

   103

		return *GetActiveBlitter();

   104

	}

   105

   106

   107

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

   108

	{

   109

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

   110

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

   111

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

   112

			BlitterFactoryBase *b = (*it).second;

   113

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

   114

		}

   115

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

   116

   117

		return p;

   118

	}

   119

   120

	/**

   121

	 * Get a nice description of the blitter-class.

   122

	 */

   123

	virtual const char *GetDescription() = 0;

   124

   125

	/**

   126

	 * Create an instance of this Blitter-class.

   127

	 */

   128

	virtual Blitter *CreateInstance() = 0;

   129

};

   130

   131

/**

   132

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

   133

 */

   134

template <class T>

   135

class BlitterFactory: public BlitterFactoryBase {

   136

public:

   137

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

   138

   139

	/**

   140

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

   141

	 */

   142

	const char *GetName();

   143

};

   144

   145

extern char _ini_blitter[32];

   146

   147

#endif /* BLITTER_FACTORY_HPP */