void PUObserver::copyAttributesTo( PUObserver* observer )
{
// Copy attributes
observer->setName(_name);
observer->setObserverType(_observerType);
observer->_particleTypeToObserve = _particleTypeToObserve;
observer->_particleTypeToObserveSet = _particleTypeToObserveSet;
observer->_particleSystem = _particleSystem;
observer->_observerScale = _observerScale;
observer->_observerInterval = _observerInterval;
observer->_observerIntervalRemainder = _observerIntervalRemainder;
observer->_observerIntervalSet = _observerIntervalSet;
observer->_observeUntilEvent = _observeUntilEvent;
observer->_eventHandlersExecuted = _eventHandlersExecuted;
observer->_enabled = _enabled;
observer->_originalEnabled = _originalEnabled;
observer->_originalEnabledSet = _originalEnabledSet;
// Copy event handlers
size_t i = 0;
PUEventHandler* eventHandler = 0;
for(i = 0; i < getNumEventHandlers(); ++i)
{
eventHandler = getEventHandler(i);
PUEventHandler *clonedEventHandler = PUEventHandlerManager::Instance()->createEventHandler(eventHandler->getEventHandlerType());
eventHandler->copyAttributesTo(clonedEventHandler);
observer->addEventHandler(clonedEventHandler);
}
}
//////////////////
// Init the scrollbar (used by constructors)
void CScrollbar::Init()
{
iType = wid_Scrollbar;
iMin = 0;
iMax = 1;
iValue = 0;
iItemsperbox = 1;
iScrollPos = 0;
bSliderGrabbed = false;
iSliderGrabPos = 0;
bTopButtonDown = false;
bBotButtonDown = false;
bSliderDown = false;
bTopButtonOver = false;
bBotButtonOver = false;
bSliderOver = false;
bBackgroundDown = false;
bBackgroundOver = false;
iDirection.set(scrVertical, DEFAULT_PRIORITY);
pTimerData = new TimerData(this, false, 0);
tTimer = new Timer("CScrollbar", getEventHandler(this, &CScrollbar::OnTimer), pTimerData, 120);
bmpTop.set(NULL, DEFAULT_PRIORITY);
bmpBottom.set(NULL, DEFAULT_PRIORITY);
bmpSliderTop.set(NULL, DEFAULT_PRIORITY);
bmpSliderMiddle.set(NULL, DEFAULT_PRIORITY);
bmpSliderBottom.set(NULL, DEFAULT_PRIORITY);
bmpBackground.set(NULL, DEFAULT_PRIORITY);
iColor.set(Color(191, 191, 191), DEFAULT_PRIORITY);
iHighlightColor.set(Color(255, 255, 255), DEFAULT_PRIORITY);
iShadowColor.set(Color(127, 127, 127), DEFAULT_PRIORITY);
iBackgroundColor.set(Color(0, 0, 0), DEFAULT_PRIORITY);
iArrowColor.set(Color(0, 0, 0), DEFAULT_PRIORITY);
}
void CCRecordGate::unregisterEvents() {
CCLevelUpEventHandler *eventHandler = getEventHandler();
if (eventHandler) {
CCLevelUpEventDispatcher::getInstance()->removeEventHandler(eventHandler);
setEventHandler(NULL);
}
}
void GLUTCanvas::mousePressed(const int& button, const int& state, const int& x, const int& y, const int& modifier) {
// maybe there is a glutMouse that needs update
keepMouseUpdated(x, y);
// map glut event to tgt event
MouseEvent::MouseButtons pressedButton;
if (button == GLUT_LEFT_BUTTON)
pressedButton = MouseEvent::MOUSE_BUTTON_LEFT;
else if (button == GLUT_RIGHT_BUTTON)
pressedButton = MouseEvent::MOUSE_BUTTON_RIGHT;
else
pressedButton = MouseEvent::MOUSE_BUTTON_MIDDLE;
// Create tgt action and update holdButton.
MouseEvent::MouseAction action;
if (state == GLUT_DOWN) {
action = MouseEvent::PRESSED;
holdButton_ = pressedButton;
}
else{
action = MouseEvent::RELEASED;
holdButton_ = MouseEvent::MOUSE_BUTTON_NONE;
}
// calculate right TGT modifier
Event::Modifier tgtModifier = static_cast<Event::Modifier>(getModifier(modifier));
// Create and broadcast event
MouseEvent* mousePressedEvent = new MouseEvent(x, y, action, tgtModifier, pressedButton, getSize());
getEventHandler()->broadcast(mousePressedEvent);
}
//-----------------------------------------------------------------------
void ParticleObserver::copyParentAttributesTo(ParticleObserver* observer)
{
// Copy attributes
observer->setName(mName);
observer->mParticleTypeToObserve = mParticleTypeToObserve;
observer->mParticleTypeToObserveSet = mParticleTypeToObserveSet;
observer->mParentTechnique = mParentTechnique;
observer->_mObserverScale = _mObserverScale;
observer->mObserverInterval = mObserverInterval;
observer->mObserverIntervalRemainder = mObserverIntervalRemainder;
observer->mObserverIntervalSet = mObserverIntervalSet;
observer->mObserveUntilEvent = mObserveUntilEvent;
observer->mEventHandlersExecuted = mEventHandlersExecuted;
observer->mEnabled = mEnabled;
observer->mOriginalEnabled = mOriginalEnabled;
observer->mOriginalEnabledSet = mOriginalEnabledSet;
// Copy event handlers
size_t i = 0;
ParticleEventHandler* eventHandler = 0;
ParticleEventHandler* clonedEventHandler = 0;
for(i = 0; i < getNumEventHandlers(); ++i)
{
eventHandler = getEventHandler(i);
clonedEventHandler = ParticleSystemManager::getSingletonPtr()->cloneEventHandler(eventHandler);
observer->addEventHandler(clonedEventHandler);
}
}
int SelectPolicy::waitForEvent(int timeout)
{
struct timeval time;
int ret;
fd_set *set[3];
Clock clock;
while (_wait)
{
int t = this->handleTimers(timeout);
if (t >= 0)
{
time.tv_sec = t / 1000;
time.tv_usec = (t % 1000) * 1000;
}
fd_set rs = _read_set, ws = _write_set, es = _except_set;
set[0] = (_rsize == 0) ? nullptr : &rs;
set[1] = (_wsize == 0) ? nullptr : &ws;
set[2] = (_esize == 0) ? nullptr : &es;
#if defined (_WIN32)
if (!set[0] && !set[1] && !set[2])
{
Net::Clock::sleep(t);
continue ;
}
else
#endif
ret = ::select(_maxfd + 1, set[0], set[1], set[2], (t < 0) ? nullptr : &time);
if ((ret == -1 && errno == EINTR) || (ret == 0 && timeout != 0))
continue ;
if (ret == -1)
std::cerr << Net::getLastError() << std::endl;
if (ret == -1 || (ret == 0 && timeout == 0))
return ret;
if (timeout > 0)
{
timeout -= clock.getElapsedTime();
clock.update();
if (timeout < 0)
timeout = 0;
}
for (auto it = _sockets.begin(); it != _sockets.end();)
{
auto socket = it->first;
auto handler = socket->getEventHandler();
auto handle = socket->getHandle();
++it;
if (FD_ISSET(handle, &es))
handler->handleClose(*socket);
else
{
if (FD_ISSET(handle, &rs) && handler->handleInput(*socket) <= 0)
handler->handleClose(*socket);
else if (FD_ISSET(handle, &ws) && handler->handleOutput(*socket) <= 0)
handler->handleClose(*socket);
}
}
}
return 0;
}
void GLUTCanvas::passiveMouseMotion(const int& x, const int& y) {
// maybe there is a glutMouse that needs update
keepMouseUpdated(x, y);
// Create tgt and broadcast it
MouseEvent* moveEvent = new MouseEvent(x, y, MouseEvent::MOTION, Event::MODIFIER_NONE, MouseEvent::MOUSE_BUTTON_NONE, getSize());
getEventHandler()->broadcast(moveEvent);
}
static void threadCtrlCb(evutil_socket_t fd, short event, void *arg){
GLOBAL_LOG_ENTER_FUNC("");
//todo: figure out event is EV_READ.
uint8_t op;
while(-1 != read(fd, (void*)&op, 1)){}
ProtoWorkThread* workThread = reinterpret_cast<ProtoWorkThread*>(arg);
std::shared_ptr<ProtoEventHandler> eventHandler = getEventHandler(workThread);
log("eventHandler.use_count() = ", eventHandler.use_count());
eventHandler->shutdown();
GLOBAL_LOG_LEAVE_FUNC("");
}
LRESULT CALLBACK EventHandler::wndProc( HWND hWnd, UINT uMsg, WPARAM wParam,
LPARAM lParam )
{
EventHandler* handler = getEventHandler( hWnd );
if( !handler )
{
LBERROR << "Message arrived for unregistered window" << std::endl;
return DefWindowProc( hWnd, uMsg, wParam, lParam );
}
return handler->_wndProc( hWnd, uMsg, wParam, lParam );
}
void StreamStore::init()
{
if (false == this->engine.expired())
{
auto engineObject = engine.lock();
this->eventHandler = engineObject->getEventHandler();
this->streamFactory = engineObject->getStreamFactory();
this->ontology = engineObject->getOntologyInterface();
}
// this->readEntitiesFromOntology();
}
void EventEmitter::emitEvent(EventName evn) {
EventID id = getEventID(evn);
if(id == 0) return;
EventHandler evh;
try { evh = getEventHandler(id); }
catch (int err) {
//std::cout << "[EventEmitter]Warning " << err
// << ": Unknown handler id " << id << std::endl;
return;
}
evh();
}
void CSulGuiDial::init()
{
CSulGuiCanvas::init();
setWH( m_radius*2.0f, m_radius*2.0f );
CSulGeodeCircle* pCircle = new CSulGeodeCircle( m_radius );
pCircle->setOffset( osg::Vec3(m_radius, m_radius, 0.0f) );
addChild( pCircle );
m_mt = new osg::MatrixTransform;
osg::Matrix m;
m.setTrans( osg::Vec3(m_radius,m_radius,0) );
m_mt->setMatrix( m );
CSulGeomArrow2D* pArrow = new CSulGeomArrow2D( m_radius, 10.0f, 10.0f );
m_mt->addChild( pArrow );
addChild( m_mt );
getEventHandler()->wantEvent( this, this, CSulGuiEventHandler::EVENT_MOUSERELEASE );
showCanvas( false );
}
void oclFluid3D::addEventHandler(srtEvent& iEvent)
{
oclProgram::addEventHandler(iEvent);
mIntegrateCb = getEventHandler(EVT_INTEGRATE);
}
//-----------------------------------------------------------------------
void PUObserver::destroyEventHandler (size_t index)
{
destroyEventHandler(getEventHandler(index));
}
events::EventHandlerNonNull HTMLMarqueeElementImp::getOnstart()
{
return interface_cast<events::EventHandlerNonNull>(getEventHandler(u"start"));
}
events::EventHandlerNonNull HTMLMarqueeElementImp::getOnfinish()
{
return interface_cast<events::EventHandlerNonNull>(getEventHandler(u"finish"));
}
events::EventHandlerNonNull HTMLMarqueeElementImp::getOnbounce()
{
return interface_cast<events::EventHandlerNonNull>(getEventHandler(u"bounce"));
}
void CCRecordGate::registerEvents() {
if (!isOpen()) {
setEventHandler(CCRecordGateEventHandler::create(this));
CCLevelUpEventDispatcher::getInstance()->addEventHandler(getEventHandler());
}
}
void InitCacheDebug()
{
timer = new Timer("cache", getEventHandler(&CacheTimer), NULL, 10000);
timer->start();
}
