void Manager::updateTitleBuffer()
{
bool active = isActive();
Static * s = Static::instance();
TQRect tr = titleSpacer_->tqgeometry();
if (tr.width() == 0 || tr.height() == 0)
titleBuf_.resize(8, 8);
else
titleBuf_.resize(tr.size());
TQPainter p(&titleBuf_);
p.drawPixmap(0, 0, s->titleTextLeft(active));
p.drawTiledPixmap(3, 0, tr.width() - 6, Static::instance()->titleHeight(),
s->titleTextMid(active));
p.setPen(options()->color(KDecorationOptions::ColorFont, active));
p.setFont(options()->font(active));
p.drawText(4, 2, tr.width() - 8, Static::instance()->titleHeight() - 4,
AlignCenter, caption());
p.drawPixmap(tr.width() - 3, 0, s->titleTextRight(active));
}
FOG_NO_EXPORT void Object_fini(void)
{
// Destroy the shared ObjectExtra instance.
Object_extraNull.destroy();
// Destroy the memory pools.
Object_memPoolConn.destroy();
Object_memPoolExtra.destroy();
// Destroy the locks.
Object_memPoolLock.destroy();
Object::_internalLock.destroy();
}
int main()
{
Shared shlib;
Static stlib;
std::cout << "Static library subtract(5, 3): ";
std::cout << stlib.subtract(5, 3) << std::endl;
std::cout << "Shared library add(4, 5): ";
std::cout << shlib.add(4, 5) << std::endl;
return EXIT_SUCCESS;
}
TEST_F(MathMatrixStaticTest, Inversion) {
// 2x2
Static<double,2,2> c;
c(0,0) = -5.0; c(0,1) = 2.0;
c(1,0) = 3.0; c(1,1) = -1.0;
EXPECT_EQ(c, a_.invert());
EXPECT_EQ(a_, a_.invert().invert());
EXPECT_EQ(b_, b_.invert().invert());
// 3x3
Static<double,3,3> d;
d(0,0) = 1.0; d(0,1) = 5.0; d(0,2) = 13.0;
d(1,0) = 2.0; d(1,1) = 7.0; d(1,2) = 17.0;
d(2,0) = 3.0; d(2,1) = 11.0; d(2,2) = 19.0;
EXPECT_EQ(d, d.invert().invert());
}
void Win32Painter::Create(Widget *w)
{
Button *button;
Static *label;
TextField *textField;
HINSTANCE inst = (HINSTANCE)GetWindowLong(parent_, GWL_HINSTANCE);
if ((button=dynamic_cast<Button*>(w))) {
hwnd_ = CreateWindow("BUTTON",button->Label().c_str(),WS_CHILD|WS_VISIBLE|BS_PUSHBUTTON,button->X(),button->Y(),button->Width(),button->Height(),parent_,NULL,inst,NULL);
} else if ((label=dynamic_cast<Static*>(w))) {
hwnd_ = CreateWindow("STATIC",label->Label().c_str(),WS_CHILD|WS_VISIBLE|SS_LEFT,label->X(),label->Y(),label->Width(),label->Height(),parent_,NULL,inst,NULL);
} else if ((textField=dynamic_cast<TextField*>(w))) {
hwnd_ = CreateWindow("EDIT",textField->Text().c_str(),WS_CHILD|WS_VISIBLE|ES_LEFT|ES_AUTOHSCROLL|WS_BORDER,textField->X(),textField->Y(),textField->Width(),textField->Height(),parent_,NULL,inst,NULL);
}
originalWndProc_ = (WNDPROC)SetWindowLong(hwnd_, GWL_WNDPROC, (LONG)WndProc);
SetWindowLong(hwnd_, GWL_USERDATA, (LONG)w);
}
static void ObjectExtra_destroy(ObjectExtra* extra)
{
extra->~ObjectExtra();
{ // Synchronized.
AutoLock locked(Object_memPoolLock);
Object_memPoolExtra->free(extra);
}
}
EventLoopImpl* Application::createEventLoop(const StringW &_name)
{
StringW name(_name);
// Redirect "Core" to "Core.Default".
if (name == Ascii8("Core"))
name.setAscii8("Core.Default");
return Application_local->createEventLoop(name);
}
void OnLButtonDown(POINT p) {
if (!s)
{
s.Create(*this, WS_CHILD | WS_VISIBLE, "X", SHIP_ID, p.x, p.y, 15, 20);
}
else
{
SetWindowPos(s, NULL, p.x, p.y, 0, 0, SWP_NOSIZE | SWP_NOZORDER);
}
cp = p;
}
TEST_F(MathMatrixStaticTest, BasicOperations) {
Static<double,2,2> c;
// Addition
c(0,0) = 8.0; c(0,1) = 13.0;
c(1,0) = 16.0; c(1,1) = 22.0;
EXPECT_EQ(c, a_ + b_);
// Product
c(0,0) = 33.0; c(0,1) = 45.0;
c(1,0) = 86.0; c(1,1) = 118.0;
EXPECT_EQ(c, a_ * b_);
// Operator+=
c.zeros();
Static<double,2,2> def;
EXPECT_EQ(c, def);
c += a_;
EXPECT_EQ(c, a_);
EXPECT_EQ(c *= 2.0, a_ * 2.0);
// Transpose
EXPECT_EQ(a_, a_.transpose().transpose());
}
void OnLButtonDown(POINT p) {
if (!ship) {
ship.Create(*this, WS_VISIBLE | WS_CHILD, "x", NULL, p.x, p.y, SHIP_WIDTH, SHIP_HEIGHT);
pos.x = p.x;
pos.y = p.y;
} //kreiraj brod i zapamti vrijednosti koordinata
SetWindowPos(ship,NULL, p.x, p.y, 0, 0, SWP_NOSIZE | SWP_NOZORDER);
pos.x = p.x;
pos.y = p.y; //promijeni koordinate broda i zapamti nove vrijednosti
}
static ObjectExtra* ObjectExtra_create()
{
ObjectExtra* extra;
{ // Synchronized.
AutoLock locked(Object_memPoolLock);
extra = reinterpret_cast<ObjectExtra*>(Object_memPoolExtra->alloc(sizeof(ObjectExtra)));
if (FOG_IS_NULL(extra))
return NULL;
}
return fog_new_p(extra) ObjectExtra();
}
FOG_NO_EXPORT void Object_init(void)
{
// Initialize the Object meta class.
static MetaClass _privateObjectMetaClass;
static const char _privateObjectClassName[] = "Fog::Object";
_privateObjectMetaClass.base = NULL;
_privateObjectMetaClass.name = _privateObjectClassName;
_privateObjectMetaClass.hashCode = HashUtil::hash(StubA(_privateObjectClassName, FOG_ARRAY_SIZE(_privateObjectClassName) - 1));
Object::_staticMetaClass = &_privateObjectMetaClass;
// Initialize the locks.
Object::_internalLock.init();
Object_memPoolLock.init();
// Initialize the memory pools.
Object_memPoolExtra.init();
Object_memPoolConn.init();
// Initialize the ObjectExtra null (initial) instance.
Object_extraNull.init();
}
void Manager::paintEvent(TQPaintEvent *e)
{
TQPainter p(widget());
TQRect r(e->rect());
bool intersectsLeft = r.intersects(TQRect(0, 0, 1, height()));
bool intersectsRight =
r.intersects(TQRect(width() - 1, 0, width(), height()));
if (intersectsLeft || intersectsRight)
{
p.setPen(TQt::black);
if (intersectsLeft)
p.drawLine(0, r.top(), 0, r.bottom());
if (intersectsRight)
p.drawLine(width() - 1, r.top(), width() - 1, r.bottom());
}
Static * s = Static::instance();
bool active = isActive();
// Title bar.
TQRect tr = titleSpacer_->tqgeometry();
bitBlt(widget(), tr.topLeft(), &titleBuf_);
// Resize bar.
if (isResizable())
{
int rbt = height() - Static::instance()->resizeHeight(); // Resize bar top
bitBlt(widget(), 0, rbt, &(s->resize(active)));
bitBlt(widget(), 30, rbt, &(s->resizeMidLeft(active)));
p.drawTiledPixmap(32, rbt, width() - 34,
Static::instance()->resizeHeight(),
s->resizeMidMid(active));
bitBlt(widget(), width() - 32, rbt, &(s->resizeMidRight(active)));
bitBlt(widget(), width() - 30, rbt, &(s->resize(active)));
}
else
p.drawLine(1, height() - 1, width() - 2, height() - 1);
}
FOG_NO_EXPORT void Application_init(void)
{
Application_local.init();
// --------------------------------------------------------------------------
// [Default]
// --------------------------------------------------------------------------
Application::registerEventLoop(FOG_S(APPLICATION_Core_Default), Application_DefaultEventLoopConstructor);
// --------------------------------------------------------------------------
// [Windows]
// --------------------------------------------------------------------------
#if defined(FOG_OS_WINDOWS)
Application::registerEventLoop(FOG_S(APPLICATION_Core_Win), Application_WinEventLoopConstructor);
# if defined(FOG_BUILD_UI)
Application::registerUIEngine(FOG_S(APPLICATION_UI_Win), Application_WinUIEngineConstructor);
# endif // FOG_BUILD_UI
#endif // FOG_OS_WINDOWS
// --------------------------------------------------------------------------
// [Mac]
// --------------------------------------------------------------------------
#if defined(FOG_OS_MAC)
Application::registerEventLoop(FOG_S(APPLICATION_Core_Mac), Application_MacEventLoopConstructor);
# if defined(FOG_BUILD_UI)
Application::registerUIEngine(FOG_S(APPLICATION_UI_Mac), Application_MacUIEngineConstructor);
# endif // FOG_BUILD_UI && FOG_OS_MAC
#endif // FOG_OS_MAC
// --------------------------------------------------------------------------
// [X11]
// --------------------------------------------------------------------------
#if defined(FOG_BUILD_UI_X11) && !defined(FOG_BUILD_UI_X11_MODULE)
Application::registerUIEngine(FOG_S(APPLICATION_UI_X11), Application_X11UIEngineConstructor);
#endif // FOG_BUILD_UI_X11 && !FOG_BUILD_UI_X11_MODULE
}
UIEngine* Application::createUIEngine(const StringW& _name)
{
StringW name(_name);
// First try to detect UIEngine if not specified
if (name == Ascii8("UI"))
name = detectUIEngine();
// Try to create UIEngine using list of registered 'UIEngine's.
UIEngine* engine = Application_local->createUIEngine(name);
if (engine)
return engine;
// Try to load dynamically linked library in form FogUI_${name}.
if (!name.startsWith(Ascii8("UI.")))
return NULL;
// Extract the name of engine from UI.${name}.
name.remove(Range(0, 3));
Library lib;
err_t err = lib.openPlugin(StringW::fromAscii8("FogUI"), name);
if (FOG_IS_ERROR(err))
{
Logger::error("Fog::Application", "createUIEngine",
"Failed to load UI library, err=%u.", err);
return NULL;
}
UIEngineConstructor ctor = (UIEngineConstructor)lib.getSymbol("ctor");
if (FOG_IS_NULL(ctor))
{
Logger::error("Fog::Application", "createUIEngine",
"Failed to get UI library constructor.");
return NULL;
}
engine = ctor();
if (FOG_IS_NULL(engine))
{
Logger::error("Fog::Application", "createUIEngine",
"Failed to invoke UI library constructor.");
return NULL;
}
if (!engine->_isInitialized)
{
Logger::error("Fog::Application", "createUIEngine",
"Failed to initialize requested engine.");
fog_delete(engine);
return NULL;
}
// Success.
engine->_library = lib;
return engine;
}
namespace Fog {
// ============================================================================
// [Fog::Object - Statics]
// ============================================================================
const MetaClass* Object::_staticMetaClass;
Static<Lock> Object::_internalLock;
static Static<ObjectExtra> Object_extraNull;
static Static<Lock> Object_memPoolLock;
static Static<MemPool> Object_memPoolExtra;
static Static<MemPool> Object_memPoolConn;
// ============================================================================
// [Fog::Object - Helpers]
// ============================================================================
static ObjectExtra* ObjectExtra_create()
{
ObjectExtra* extra;
{ // Synchronized.
AutoLock locked(Object_memPoolLock);
extra = reinterpret_cast<ObjectExtra*>(Object_memPoolExtra->alloc(sizeof(ObjectExtra)));
if (FOG_IS_NULL(extra))
return NULL;
}
return fog_new_p(extra) ObjectExtra();
}
static void ObjectExtra_destroy(ObjectExtra* extra)
{
extra->~ObjectExtra();
{ // Synchronized.
AutoLock locked(Object_memPoolLock);
Object_memPoolExtra->free(extra);
}
}
// ============================================================================
// [Fog::Object - Construction / Destruction]
// ============================================================================
enum { OBJECT_VTYPE_FLAGS = OBJECT_CREATE_STATIC };
enum { OBJECT_ADOPT_FLAGS = OBJECT_CREATE_WRAPPED };
Object::Object(uint32_t createFlags) :
_vType(VAR_TYPE_OBJECT_REF | VAR_FLAG_NONE | (createFlags & OBJECT_VTYPE_FLAGS)),
_objectFlags(createFlags & OBJECT_ADOPT_FLAGS),
_objectExtra(&Object_extraNull),
_parent(NULL),
_homeThread(Thread::getCurrentThread()),
_events(NULL)
{
}
Object::~Object()
{
ObjectExtra* extra = _objectExtra;
if (extra != &Object_extraNull)
{
// Delete all children.
err_t err = _removeAll();
if (FOG_IS_ERROR(err))
{
Logger::error("Fog::Object", "~Object",
"_removeAll() failed, error=%u.", err);
}
// Delete all connections.
if (!extra->_forwardConnection.isEmpty())
{
removeAllListeners();
}
_objectExtra = &Object_extraNull;
ObjectExtra_destroy(extra);
}
// Delete all posted events.
if (_events)
{
AutoLock locked(Object::_internalLock);
// Set "wasDeleted" for all pending events.
Event* ev = _events;
while (ev)
{
// Event will be deleted by an event loop, we need only to mark it for
// deletion so it won't be processed (called).
ev->_wasDeleted = 1;
// Go to previous, because newest pending events are stored first.
ev = ev->_prev;
}
}
}
// ============================================================================
// [Fog::Object - Release]
// ============================================================================
void Object::release()
{
// First delete all children. This is last opportunity to remove them on
// current class instance (destructor changes virtual table).
err_t err = _removeAll();
if (FOG_IS_ERROR(err))
{
Logger::error("Fog::Object", "release",
"_removeAll() failed, error=%u.", err);
}
// Use delete operator only in case that the object is dynamically allocated
// using fog_new() operator.
if (!isStatic())
{
fog_delete(this);
}
}
void Object::scheduleRelease()
{
if ((_objectFlags & OBJECT_FLAG_RELEASE_SCHEDULED) != 0)
return;
Thread* thread = getHomeThread();
if (thread == NULL)
{
Logger::error("Fog::Object", "scheduleRelease",
"Can't post RELEASE event, because there is no suitable event loop.");
return;
}
_objectFlags |= OBJECT_FLAG_RELEASE_SCHEDULED;
postEvent(fog_new DestroyEvent());
}
// ============================================================================
// [Fog::Object - Object Extra]
// ============================================================================
//! @brief Get @c ObjectExtra instance ready for modification.
ObjectExtra* Object::getMutableExtra()
{
if (FOG_LIKELY(_objectExtra != &Object_extraNull))
return _objectExtra;
ObjectExtra* extra = ObjectExtra_create();
if (FOG_IS_NULL(extra))
return NULL;
_objectExtra = extra;
return extra;
}
// ============================================================================
// [Fog::Object - Meta Class]
// ============================================================================
const MetaClass* Object::getStaticMetaClass()
{
return _staticMetaClass;
}
const MetaClass* Object::_getStaticMetaClassRace(MetaClass** p)
{
while (AtomicCore<size_t>::get((size_t*)p) == 0)
{
// Yield is not optimal, but this should really rarely happen and if we
// had the luck then there is 100% probability that it will not happen
// again.
Thread::yield();
}
return *p;
}
const MetaClass* Object::getObjectMetaClass() const
{
return _staticMetaClass;
}
// ============================================================================
// [Fog::Object - Object Id]
// ============================================================================
err_t Object::setId(const StringW& id)
{
if (id == _objectExtra->_id)
return ERR_OK;
ObjectExtra* extra = getMutableExtra();
if (FOG_IS_NULL(extra))
return ERR_RT_OUT_OF_MEMORY;
FOG_RETURN_ON_ERROR(extra->_id.set(id));
return ERR_OK;
}
// ============================================================================
// [Fog::Object - Home Thread]
// ============================================================================
err_t Object::moveToThread(Thread* thread)
{
if (_homeThread == thread)
return ERR_OK;
// TODO:
return ERR_RT_NOT_IMPLEMENTED;
}
// ============================================================================
// [Fog::Object - Object Hierarchy]
// ============================================================================
err_t Object::setParent(Object* parent)
{
// If our parent is a given parent then do nothing, it's not error.
if (_parent == parent)
return ERR_OK;
// If we have a parent then it's needed to break the hierarchy first.
if (_parent != NULL)
FOG_RETURN_ON_ERROR(_parent->removeChild(this));
// Now set the new parent. NULL is valid value so we must make sure the
// object is not null before calling its method.
if (parent)
FOG_RETURN_ON_ERROR(parent->addChild(this));
return ERR_OK;
}
err_t Object::addChild(Object* child)
{
if (FOG_IS_NULL(child))
return ERR_RT_INVALID_ARGUMENT;
// If object is already in our hierarchy then we return quickly.
if (child->getParent() == this)
return ERR_OK;
// If object has different parent then it's an error.
if (child->hasParent())
return ERR_OBJECT_HAS_PARENT;
// Okay, now we can call the virtual _addChild() method.
return _addChild(_objectExtra->_children.getLength(), child);
}
err_t Object::removeChild(Object* child)
{
if (FOG_IS_NULL(child))
return ERR_RT_INVALID_ARGUMENT;
if (child->getParent() != this)
return ERR_OBJECT_NOT_FOUND;
size_t index = _objectExtra->_children.indexOf(child);
// It must be here if parent check passed!
FOG_ASSERT(index != INVALID_INDEX);
// Okay, now we can call the virtual _removeChild() method.
return _removeChild(index, child);
}
err_t Object::_addChild(size_t index, Object* child)
{
// Index must be valid or equal to children list length.
FOG_ASSERT(index <= _objectExtra->_children.getLength());
ObjectExtra* extra = getMutableExtra();
if (FOG_IS_NULL(extra))
return ERR_RT_OUT_OF_MEMORY;
FOG_RETURN_ON_ERROR(extra->_children.insert(index, child));
child->_parent = this;
// Send 'child-add' event.
ChildEvent e(EVENT_CHILD_ADD, child);
sendEvent(&e);
return ERR_OK;
}
err_t Object::_removeChild(size_t index, Object* child)
{
ObjectExtra* extra = _objectExtra;
// Index must be valid.
FOG_ASSERT(index < extra->_children.getLength() &&
child == extra->_children.getAt(index));
// Extra must be mutable if we found the children.
FOG_ASSERT(extra != &Object_extraNull);
FOG_RETURN_ON_ERROR(extra->_children.removeAt(index));
child->_parent = NULL;
// Send 'child-remove' event.
ChildEvent e(EVENT_CHILD_REMOVE, child);
sendEvent(&e);
return ERR_OK;
}
err_t Object::_removeAll()
{
ObjectExtra* extra = _objectExtra;
if (extra->_children.isEmpty())
return ERR_OK;
err_t err = ERR_OK;
size_t index;
while ((index = extra->_children.getLength()) != 0)
{
Object* child = extra->_children.getAt(--index);
err = _removeChild(index, child);
if (FOG_IS_ERROR(err))
break;
}
return err;
}
// ============================================================================
// [Fog::Object - Property - Validate]
// ============================================================================
// Object name can contain characters [A-Z], [a-z], '-', '_', [0-9]. Numbers
// are not allowed for the first character.
static err_t Object_validatePropertyName(const StringW& name)
{
const CharW* data = name.getData();
size_t length = name.getLength();
if (length == 0)
return ERR_PROPERTY_INVALID;
CharW c = data[0];
if (!(c.isAsciiLetter() || c == CharW('_') || c == CharW('-')))
return ERR_PROPERTY_INVALID;
for (size_t i = 1; i < length; i++)
{
if (!(c.isAsciiNumlet() || c == CharW('_') || c == CharW('-')))
return ERR_PROPERTY_INVALID;
}
return ERR_OK;
}
// ============================================================================
// [Fog::Object - Property - Dynamic]
// ============================================================================
static err_t Object_getDynamicProperty(const Object* self, const InternedStringW& name, Var& dst)
{
const ObjectExtra* extra = self->_objectExtra;
if (extra == &Object_extraNull)
return ERR_PROPERTY_NOT_FOUND;
const Var* var = extra->_properties.getPtr(name);
if (var == NULL)
return ERR_PROPERTY_NOT_FOUND;
else
return dst.setVar(*var);
}
static err_t Object_setDynamicProperty(Object* self, const InternedStringW& name, const Var& src)
{
ObjectExtra* extra = self->getMutableExtra();
if (FOG_IS_NULL(extra))
return ERR_RT_OUT_OF_MEMORY;
Var* var = extra->_properties.usePtr(name);
if (var != NULL)
{
if (*var == src)
return ERR_OK;
FOG_RETURN_ON_ERROR(var->setVar(src));
}
else
{
FOG_RETURN_ON_ERROR(extra->_properties.put(name, src));
}
PropertyEvent e(name);
self->sendEvent(&e);
return ERR_OK;
}
// ============================================================================
// [Fog::Object - Property - Accessors]
// ============================================================================
err_t Object::getProperty(const StringW& name, Var& dst) const
{
InternedStringW m_name(name, INTERNED_STRING_OPTION_LOOKUP);
if (m_name.isEmpty())
{
FOG_RETURN_ON_ERROR(Object_validatePropertyName(name));
// If the property name is valid then we must ERR_PROPERTY_NOT_FOUND.
return ERR_PROPERTY_NOT_FOUND;
}
else
{
err_t err = _getProperty(m_name, dst);
// If the property doesn't exist try dynamically added properties.
if (err == ERR_PROPERTY_NOT_FOUND)
err = Object_getDynamicProperty(this, m_name, dst);
return err;
}
}
err_t Object::setProperty(const StringW& name, const Var& src)
{
InternedStringW m_name(name, INTERNED_STRING_OPTION_LOOKUP);
if (m_name.isEmpty())
{
// Return error if the property name isn't valid. We are going to create
// new InternedStringW so we must be sure that the internal hash table used
// to store interned strings won't be polluted by strings we actually don't
// need.
FOG_RETURN_ON_ERROR(Object_validatePropertyName(name));
// Create a new InternedStringW.
FOG_RETURN_ON_ERROR(m_name.set(name));
}
else
{
// We know that there is a InternedStringW, so try Object::_setProperty().
err_t err = _setProperty(m_name, src);
// If something bad happened (for example wrong argument type) then we
// report it immediately.
if (err != ERR_PROPERTY_NOT_FOUND)
return err;
// We are going to set dynamic property (this means that it can be created)
// so we must be sure that the property name is valid.
FOG_RETURN_ON_ERROR(Object_validatePropertyName(name));
}
// Set dynamic property.
return Object_setDynamicProperty(this, m_name, src);
}
err_t Object::getProperty(const InternedStringW& name, Var& dst) const
{
err_t err = _getProperty(name, dst);
if (err != ERR_PROPERTY_NOT_FOUND)
return err;
err = Object_getDynamicProperty(this, name, dst);
if (err != ERR_PROPERTY_NOT_FOUND)
return err;
FOG_RETURN_ON_ERROR(Object_validatePropertyName(name));
return ERR_PROPERTY_NOT_FOUND;
}
err_t Object::setProperty(const InternedStringW& name, const Var& src)
{
err_t err = _setProperty(name, src);
if (err != ERR_PROPERTY_NOT_FOUND)
return err;
// If property doesn't exist create a dynamic property.
FOG_RETURN_ON_ERROR(Object_validatePropertyName(name));
return Object_setDynamicProperty(this, name, src);
}
// ============================================================================
// [Fog::Object - Property - Virtual]
// ============================================================================
err_t Object::_getProperty(const InternedStringW& name, Var& dst) const
{
FOG_UNUSED(name);
FOG_UNUSED(dst);
if (name == FOG_S(id))
return dst.setString(_objectExtra->_id);
return ERR_PROPERTY_NOT_FOUND;
}
err_t Object::_setProperty(const InternedStringW& name, const Var& src)
{
FOG_UNUSED(name);
FOG_UNUSED(src);
if (name == FOG_S(id))
{
StringW src_string;
FOG_RETURN_ON_ERROR(src.getString(src_string));
return setId(src_string);
}
return ERR_PROPERTY_NOT_FOUND;
}
// ============================================================================
// [Fog::Object - Listeners]
// ============================================================================
bool Object::addListener(uint32_t code, void (*fn)(Event*))
{
Delegate1<Event*> del(fn);
return _addListener(code, NULL, (const void*)&del, OBJECT_EVENT_HANDLER_EVENTPTR);
}
bool Object::addListener(uint32_t code, void (*fn)())
{
Delegate0<> del(fn);
return _addListener(code, NULL, (const void*)&del, OBJECT_EVENT_HANDLER_VOID);
}
bool Object::removeListener(uint32_t code, void (*fn)(Event*))
{
Delegate1<Event*> del(fn);
return _removeListener(code, NULL, (const void*)&del, OBJECT_EVENT_HANDLER_EVENTPTR);
}
bool Object::removeListener(uint32_t code, void (*fn)())
{
Delegate0<> del(fn);
return _removeListener(code, NULL, (const void*)&del, OBJECT_EVENT_HANDLER_VOID);
}
uint Object::removeListener(Object* listener)
{
ObjectExtra* extra = _objectExtra;
if (extra == &Object_extraNull)
return 0;
AutoLock locked(Object::_internalLock);
uint result = 0;
ObjectConnection* prev;
ObjectConnection* conn;
ObjectConnection* next;
_Begin:
{
HashIterator<uint32_t, ObjectConnection*> it(extra->_forwardConnection);
while (it.isValid())
{
uint32_t key = it.getKey();
prev = NULL;
conn = it.getItem();
do {
next = conn->next;
if (conn->listener == listener)
{
result++;
if (listener)
{
size_t index = listener->_objectExtra->_backwardConnection.indexOf(conn);
FOG_ASSERT(index != INVALID_INDEX);
listener->_objectExtra->_backwardConnection.removeAt(index);
}
fog_delete(conn);
if (prev)
prev->next = next;
else if (next)
{
extra->_forwardConnection.put(key, next);
goto _Begin;
}
else
{
extra->_forwardConnection.remove(key);
goto _Begin;
}
}
prev = conn;
conn = next;
} while (conn);
it.next();
}
}
return result;
}
uint Object::removeAllListeners()
{
ObjectExtra* extra = _objectExtra;
if (extra == &Object_extraNull)
return 0;
AutoLock locked(Object::_internalLock);
uint result = 0;
ObjectConnection* conn;
ObjectConnection* next;
HashIterator<uint32_t, ObjectConnection*> it(extra->_forwardConnection);
while (it.isValid())
{
conn = it.getItem();
do {
next = conn->next;
result++;
if (conn->listener)
{
size_t index = conn->listener->_objectExtra->_backwardConnection.indexOf(conn);
FOG_ASSERT(index != INVALID_INDEX);
conn->listener->_objectExtra->_backwardConnection.removeAt(index);
}
fog_delete(conn);
conn = next;
} while (conn);
it.next();
}
extra->_forwardConnection.clear();
return result;
}
// Private.
bool Object::_addListener(uint32_t code, Object* listener, const void* del, uint32_t type)
{
AutoLock locked(Object::_internalLock);
ObjectExtra* extra = getMutableExtra();
if (FOG_IS_NULL(extra))
return false;
if (listener->getMutableExtra() == NULL)
return false;
ObjectConnection* prev = NULL;
ObjectConnection* conn = extra->_forwardConnection.get(code, NULL);
Delegate0<> d = *(const Delegate0<> *)del;
if (conn)
{
do {
if (conn->delegateVoid() == d)
return false;
prev = conn;
conn = conn->next;
} while (conn);
}
conn = fog_new ObjectConnection;
// TODO: if (conn == NULL) ...
conn->next = NULL;
conn->attachedObject = this;
conn->listener = listener;
conn->delegateVoid() = d;
conn->type = type;
conn->code = code;
if (prev)
prev->next = conn;
else
extra->_forwardConnection.put(code, conn);
if (listener)
listener->_objectExtra->_backwardConnection.append(conn);
return true;
}
bool Object::_removeListener(uint32_t code, Object* listener, const void* del, uint32_t type)
{
ObjectExtra* extra = _objectExtra;
if (FOG_IS_NULL(extra))
return false;
AutoLock locked(Object::_internalLock);
ObjectConnection* prev = NULL;
ObjectConnection* conn = extra->_forwardConnection.get(code, NULL);
if (!conn) return false;
Delegate0<> d = *(const Delegate0<> *)del;
do {
ObjectConnection* next = conn->next;
if (conn->delegateVoid() == d)
{
FOG_ASSERT(conn->listener == listener);
if (prev)
prev->next = next;
else if (next)
extra->_forwardConnection.put(code, next);
else
extra->_forwardConnection.remove(code);
if (listener)
{
size_t index = listener->_objectExtra->_backwardConnection.indexOf(conn);
FOG_ASSERT(index != INVALID_INDEX);
listener->_objectExtra->_backwardConnection.removeAt(index);
}
fog_delete(conn);
return true;
}
prev = conn;
conn = next;
} while (conn);
return false;
}
// OBJECT TODO: Add removing possibility for currently called listeners
void Object::_callListeners(Event* ev)
{
ObjectExtra* extra = _objectExtra;
if (FOG_IS_NULL(extra))
return;
uint32_t code = ev->getCode();
ObjectConnection* conn = extra->_forwardConnection.get(code, NULL);
if (!conn) return;
do {
switch (conn->type)
{
case OBJECT_EVENT_HANDLER_VOID:
conn->delegateVoid()();
break;
case OBJECT_EVENT_HANDLER_EVENTPTR:
conn->delegateEvent()(ev);
break;
default:
FOG_ASSERT_NOT_REACHED();
break;
}
} while ((conn = conn->next));
}
// ============================================================================
// [Fog::Object - Event Management]
// ============================================================================
void Object::postEvent(Event* ev)
{
Thread* thread = getHomeThread();
if (FOG_IS_NULL(thread))
goto _Fail;
if (!thread->getEventLoop().isCreated())
goto _Fail;
// Link event with object`s event queue.
{
AutoLock locked(_internalLock);
ev->_prev = this->_events;
this->_events = ev;
ev->_flags |= Event::IS_POSTED;
}
// Post event (event is posted as task).
thread->getEventLoop().postTask(ev);
return;
_Fail:
Logger::error("Fog::Object", "postEvent",
"Can't post event to object which has no home thread or event loop. Event destroyed!");
fog_delete(ev);
}
void Object::postEvent(uint32_t code)
{
Event* ev = fog_new Event(code, 0);
if (ev) postEvent(ev);
}
void Object::sendEvent(Event* ev)
{
// First set receiver to self.
ev->_receiver = this;
// Send event to object onEvent().
onEvent(ev);
// Send event to listeners.
_callListeners(ev);
}
void Object::sendEventByCode(uint32_t code)
{
Event e(code, 0);
sendEvent(&e);
}
// ============================================================================
// [Fog::Object - Event Handlers]
// ============================================================================
// The onEvent() method is normally defined by FOG_EVENT_BEGIN() and
// FOG_EVENT_END() macros, but Fog::Object is an exception.
void Object::onEvent(Event* ev)
{
switch (ev->getCode())
{
case EVENT_CREATE:
onCreate(reinterpret_cast<CreateEvent*>(ev));
break;
case EVENT_DESTROY:
onDestroy(reinterpret_cast<DestroyEvent*>(ev));
break;
case EVENT_CHILD_ADD:
case EVENT_CHILD_REMOVE:
onChild(reinterpret_cast<ChildEvent*>(ev));
break;
case EVENT_PROPERTY:
onProperty(reinterpret_cast<PropertyEvent*>(ev));
break;
}
}
void Object::onCreate(CreateEvent* ev) {}
void Object::onDestroy(DestroyEvent* ev) {}
void Object::onChild(ChildEvent* ev) {}
void Object::onProperty(PropertyEvent* ev) {}
// ============================================================================
// [Init / Fini]
// ============================================================================
FOG_NO_EXPORT void Object_init(void)
{
// Initialize the Object meta class.
static MetaClass _privateObjectMetaClass;
static const char _privateObjectClassName[] = "Fog::Object";
_privateObjectMetaClass.base = NULL;
_privateObjectMetaClass.name = _privateObjectClassName;
_privateObjectMetaClass.hashCode = HashUtil::hash(StubA(_privateObjectClassName, FOG_ARRAY_SIZE(_privateObjectClassName) - 1));
Object::_staticMetaClass = &_privateObjectMetaClass;
// Initialize the locks.
Object::_internalLock.init();
Object_memPoolLock.init();
// Initialize the memory pools.
Object_memPoolExtra.init();
Object_memPoolConn.init();
// Initialize the ObjectExtra null (initial) instance.
Object_extraNull.init();
}
FOG_NO_EXPORT void Object_fini(void)
{
// Destroy the shared ObjectExtra instance.
Object_extraNull.destroy();
// Destroy the memory pools.
Object_memPoolConn.destroy();
Object_memPoolExtra.destroy();
// Destroy the locks.
Object_memPoolLock.destroy();
Object::_internalLock.destroy();
}
} // Fog namespace
FOG_NO_EXPORT void Application_fini(void)
{
Application_local.destroy();
}
void MapRenderer::createFastKeys(int tilex, int tiley, int maxtilex, int maxtiley) {
if (tilex < 0)
tilex = 0;
if (tiley < 0)
tiley = 0;
if (maxtilex >= pMap_->maxX())
maxtilex = pMap_->maxX();
if (maxtiley >= pMap_->maxY())
maxtiley = pMap_->maxY();
cache_vehicles_.clear();
cache_peds_.clear();
cache_weapons_.clear();
cache_statics_.clear();
cache_sfx_objects_.clear();
fast_vehicle_cache_.clear();
fast_ped_cache_.clear();
fast_weapon_cache_.clear();
fast_statics_cache_.clear();
fast_sfx_objects_cache_.clear();
// updating position for visual markers
for (size_t i = 0; i < AgentManager::kMaxSlot; i++) {
PedInstance *p = pMission_->getSquad()->member(i);
if (p != NULL && p->isAlive()) {
if (p->tileX() >= tilex && p->tileX() < maxtilex
&& p->tileY() >= tiley && p->tileY() < maxtiley) {
// sfx_objects_[i]->setPosition(p->tileX(), p->tileY(), p->tileZ(),
// p->offX(), p->offY(), p->offZ() + 320);
pMission_->sfxObjects(i + 4)->setPosition(p->tileX(), p->tileY(),
p->tileZ(), p->offX() - 16, p->offY(), p->offZ() + 256);
}
} else {
// sfx_objects_[i]->setMap(-1);
pMission_->sfxObjects(i + 4)->setMap(-1);
}
}
// vehicles
for (unsigned int i = 0; i < pMission_->numVehicles(); i++) {
Vehicle *v = pMission_->vehicle(i);
if (v->tileX() >= tilex && v->tileX() < maxtilex
&& v->tileY() >= tiley && v->tileY() < maxtiley) {
// NOTE: a trick to make vehicles be drawn correctly z+1
fast_vehicle_cache_.insert(fastKey(v->tileX(),
v->tileY(), v->tileZ() + 1));
cache_vehicles_.push_back(v);
}
}
// peds
for (size_t i = 0; i < AgentManager::kMaxSlot; i++) {
PedInstance *p = pMission_->getSquad()->member(i);
if (p != NULL && p->map() != -1) {
if (p->tileX() >= tilex && p->tileX() < maxtilex
&& p->tileY() >= tiley && p->tileY() < maxtiley) {
fast_ped_cache_.insert(fastKey(p));
cache_peds_.push_back(p);
}
}
}
for (size_t i = pMission_->getSquad()->size(); i < pMission_->numPeds(); i++) {
PedInstance *p = pMission_->ped(i);
if (p->map() != -1) {
if (p->tileX() >= tilex && p->tileX() < maxtilex
&& p->tileY() >= tiley && p->tileY() < maxtiley) {
fast_ped_cache_.insert(fastKey(p));
cache_peds_.push_back(p);
}
}
}
// weapons
for (unsigned int i = 0; i < pMission_->numWeapons(); i++) {
WeaponInstance *w = pMission_->weapon(i);
if (w->map() != -1 && w->tileX() >= tilex && w->tileX() < maxtilex
&& w->tileY() >= tiley && w->tileY() < maxtiley) {
fast_weapon_cache_.insert(fastKey(w));
cache_weapons_.push_back(w);
}
}
// statics
for (unsigned int i = 0; i < pMission_->numStatics(); i++) {
Static *s = pMission_->statics(i);
if (s->tileX() >= tilex && s->tileX() < maxtilex
&& s->tileY() >= tiley && s->tileY() < maxtiley) {
fast_statics_cache_.insert(fastKey(s));
cache_statics_.push_back(s);
}
}
// sfx objects
for (unsigned int i = 0; i < pMission_->numSfxObjects(); i++) {
SFXObject *so = pMission_->sfxObjects(i);
if (so->map() != -1 && so->tileX() >= tilex && so->tileX() < maxtilex
&& so->tileY() >= tiley && so->tileY() < maxtiley) {
fast_sfx_objects_cache_.insert(fastKey(so));
cache_sfx_objects_.push_back(so);
}
}
}
