1

/* $Id$ */

     2

     3

#include "../stdafx.h"

     4

#include <stdarg.h>

     5

#include "../openttd.h"

     6

#include "../debug.h"

     7

#include "../functions.h"

     8

#include "../map.h"

     9

#include "../player.h"

    10

#include "../window.h"

    11

#include "../gfx.h"

    12

#include "../viewport.h"

    13

#include "../console.h"

    14

#include "../variables.h"

    15

#include "../table/sprites.h"

    16

#include "../genworld.h"

    17

#include "../helpers.hpp"

    18

#include "window_events.hpp"

    19

    20

namespace gui {

    21

    22

EventCaptureStack::CaptureTicket::CaptureTicket()

    23

	: m_it(EventCaptureStack::GetInstance().m_handlers.end())

    24

{}

    25

    26

EventCaptureStack::CaptureTicket::CaptureTicket(EventCaptureStack::Handlers::iterator it)

    27

: m_it(it)

    28

{}

    29

    30

EventCaptureStack::CaptureTicket::CaptureTicket(const CaptureTicket &src)

    31

	: m_it(src.Detach())

    32

{}

    33

    34

EventCaptureStack::CaptureTicket::~CaptureTicket()

    35

{

    36

	Release();

    37

}

    38

    39

bool EventCaptureStack::CaptureTicket::IsActive() const

    40

{

    41

	return m_it != EventCaptureStack::GetInstance().m_handlers.end();

    42

}

    43

    44

EventCaptureStack::CaptureTicket& EventCaptureStack::CaptureTicket::operator = (const CaptureTicket &src)

    45

{

    46

	Attach(src.Detach());

    47

	return *this;

    48

}

    49

    50

void EventCaptureStack::CaptureTicket::Attach(EventCaptureStack::Handlers::iterator it)

    51

{

    52

	Release();

    53

	m_it = it;

    54

}

    55

    56

EventCaptureStack::Handlers::iterator EventCaptureStack::CaptureTicket::Detach() const

    57

{

    58

	EventCaptureStack::Handlers::iterator it = m_it;

    59

	m_it = EventCaptureStack::GetInstance().m_handlers.end();

    60

	return it;

    61

}

    62

    63

void EventCaptureStack::CaptureTicket::Release()

    64

{

    65

	EventCaptureStack &stack = EventCaptureStack::GetInstance();

    66

	EventCaptureStack::Handlers &handlers = stack.m_handlers;

    67

	if (m_it != handlers.end()) {

    68

		stack.InternalRemove(m_it);

    69

		m_it = handlers.end();

    70

	}

    71

}

    72

    73

EventCaptureStack::Handlers::iterator EventCaptureStack::InternalAdd(EventHandlerDelegate *delegate)

    74

{

    75

	EventCaptureStack::Handlers::iterator it = m_handlers.insert(m_handlers.begin(), EventHandlerDelegatePtr(delegate));

    76

	return it;

    77

}

    78

    79

void EventCaptureStack::InternalRemove(EventCaptureStack::Handlers::iterator it)

    80

{

    81

	if (it != m_handlers.end()) {

    82

		m_handlers.erase(it);

    83

	}

    84

}

    85

    86

bool EventCaptureStack::InternalHandleEvent(EventBase &e)

    87

{

    88

	/** Need to think of some better way how to walk through all items in safe way.

    89

	 * safe == "should not crash if any item is removed during handler->HandleEvent() call" */

    90

	if (m_handlers.empty()) return false;

    91

	for(Handlers::iterator it = m_handlers.begin(); it != m_handlers.end();) {

    92

		EventHandlerDelegatePtr &handler = (*it);

    93

		if (handler.IsNull() || handler->m_code != e.GetCode()) {

    94

			++it;

    95

			continue;

    96

		}

    97

		Handlers::iterator it_temp = it;

    98

		it_temp = m_handlers.insert(++it_temp, EventHandlerDelegatePtr());

    99

		handler->HandleEvent(NULL, e);

   100

		it = it_temp;

   101

		++it;

   102

		m_handlers.erase(it_temp);

   103

		if (e.IsHandled()) return true;

   104

	};

   105

	return false;

   106

}

   107

   108

//bool EventCaptureStack::InternalHandleEvent(EventBase &e)

   109

//{

   110

//	for (Handlers::reverse_iterator rit = m_handlers.rbegin(); !m_handlers.empty() && rit != m_handlers.rend();) {

   111

//		EventHandlerDelegatePtr handler = (*rit);

   112

//		++rit;

   113

//		if (handler->m_code == e.GetCode()) {

   114

//			handler->HandleEvent(NULL, e);

   115

//			if (e.IsHandled()) return true;

   116

//		}

   117

//	}

   118

//	return false;

   119

//}

   120

//

   121

/*static*/ EventCaptureStack& EventCaptureStack::GetInstance()

   122

{

   123

	static EventCaptureStack stack;

   124

	return stack;

   125

}

   126

   127

/*static*/ bool EventCaptureStack::HandleEvent(EventBase &e)

   128

{

   129

	EventCaptureStack &stack = GetInstance();

   130

	bool ret = stack.InternalHandleEvent(e);

   131

	return ret;

   132

}

   133

   134

/*static*/ EventCaptureStack::CaptureTicket EventCaptureStack::AddHandler(EventHandlerDelegate *delegate)

   135

{

   136

	EventCaptureStack &stack = GetInstance();

   137

	EventCaptureStack::Handlers::iterator it = stack.InternalAdd(delegate);

   138

	EventCaptureStack::CaptureTicket ticket(it);

   139

	return ticket;

   140

}

   141

   142

   143

}; // namespace gui

   144