1

/* $Id$ */

     2

     3

/** @file driver.h Base for all drivers (video, sound, music, etc). */

     4

     5

#ifndef DRIVER_H

     6

#define DRIVER_H

     7

     8

#include "debug.h"

     9

#include "core/enum_type.hpp"

    10

#include "string_func.h"

    11

#include <string>

    12

#include <map>

    13

    14

bool GetDriverParamBool(const char * const *parm, const char *name);

    15

int GetDriverParamInt(const char * const *parm, const char *name, int def);

    16

    17

class Driver {

    18

public:

    19

	virtual const char *Start(const char * const *parm) = 0;

    20

    21

	virtual void Stop() = 0;

    22

    23

	virtual ~Driver() { }

    24

    25

	enum Type {

    26

		DT_BEGIN = 0,

    27

		DT_SOUND = 0,

    28

		DT_MUSIC,

    29

		DT_VIDEO,

    30

		DT_END,

    31

	};

    32

};

    33

    34

DECLARE_POSTFIX_INCREMENT(Driver::Type);

    35

    36

    37

class DriverFactoryBase {

    38

private:

    39

	Driver::Type type;

    40

	char *name;

    41

	int priority;

    42

	typedef std::map<std::string, DriverFactoryBase *> Drivers;

    43

    44

	static Drivers &GetDrivers()

    45

	{

    46

		static Drivers &s_drivers = *new Drivers();

    47

		return s_drivers;

    48

	}

    49

    50

	static Driver **GetActiveDriver(Driver::Type type)

    51

	{

    52

		static Driver *s_driver[3] = { NULL, NULL, NULL };

    53

		return &s_driver[type];

    54

	}

    55

    56

	static const char *GetDriverTypeName(Driver::Type type)

    57

	{

    58

		static const char *driver_type_name[] = { "sound", "music", "video" };

    59

		return driver_type_name[type];

    60

	}

    61

    62

protected:

    63

	void RegisterDriver(const char *name, Driver::Type type, int priority);

    64

    65

public:

    66

	DriverFactoryBase() :

    67

		name(NULL)

    68

	{}

    69

    71

    72

	/** Shuts down all active drivers

    73

	 */

    74

	static void ShutdownDrivers()

    75

	{

    76

		for (Driver::Type dt = Driver::DT_BEGIN; dt < Driver::DT_END; dt++) {

    77

			Driver *driver = *GetActiveDriver(dt);

    78

			if (driver != NULL) driver->Stop();

    79

		}

    80

	}

    81

    82

	static const Driver *SelectDriver(const char *name, Driver::Type type);

    83

	static char *GetDriversInfo(char *p, const char *last);

    84

    85

	/**

    86

	 * Get a nice description of the driver-class.

    87

	 */

    88

	virtual const char *GetDescription() = 0;

    89

    90

	/**

    91

	 * Create an instance of this driver-class.

    92

	 */

    93

	virtual Driver *CreateInstance() = 0;

    94

};

    95

    96

#endif /* DRIVER_H */