bool FriendLayer::init()
{
if ( !Layer::init() )
{
return false;
}
auto friendLayer=CSLoader::createNode("FriendLayer.csb");
this->addChild(friendLayer);
Button * closeButton = static_cast<Button*>(friendLayer->getChildByName("CloseButton"));
Button * okButton = static_cast<Button*>(friendLayer->getChildByName("Button_OK"));
fname = static_cast<TextField*>(friendLayer->getChildByName("TextField_Fname"));
fshow = static_cast<Text*>(friendLayer->getChildByName("Text_show"));
closeButton->addTouchEventListener(this, toucheventselector(FriendLayer::closeEvent));
okButton->addTouchEventListener(this, toucheventselector(FriendLayer::okEvent));
EventDispatcher* eventDispatcher = Director::getInstance()->getEventDispatcher();
EventListenerTouchOneByOne* listener= EventListenerTouchOneByOne::create();
listener->setSwallowTouches(true);
listener->onTouchBegan = [](Touch* touch, Event* event){return true;};
listener->onTouchMoved = [](Touch* touch, Event* event){};
listener->onTouchEnded = [](Touch* touch, Event* event){};
listener->onTouchCancelled = [](Touch* touch , Event* event){};
eventDispatcher->addEventListenerWithSceneGraphPriority(listener, friendLayer); //代码为了设置模态窗口
return true;
}
void MouseController::shiftOver(View * n)
{
RefPtr<View> target;
target.reset(n);
if (over_ != target)
{
EventDispatcher dispatcher;
EventDispatcher::Path old_path;
EventDispatcher::GetPath(over_.get(), old_path);
EventDispatcher::Path new_path;
EventDispatcher::GetPath(n, new_path);
if (over_)
{
Point empty;
MouseEvent me(kET_MOUSE_LEAVE, kMB_NONE, over_.get(), empty, empty, 0);
dispatcher.run(me, old_path);
}
over_ = target;
root_->setCursor(::LoadImage(NULL, IDC_ARROW, IMAGE_CURSOR, 0, 0, LR_SHARED));
if (over_)
{
Point empty;
MouseEvent me(kET_MOUSE_ENTER, kMB_NONE, over_.get(), empty, empty, 0);
dispatcher.run(me, new_path);
}
}
}
void ActorHelper::fullLevelUp(unsigned int unitID)
{
int product_id = 0;
s_levelUpUnitID = unitID;
if (unitID >= ID_Actor_Start && unitID <= ID_Actor_End) {
//SdkManager::getInstance()->pay(ProductID_RoleFullLevel);
product_id = ProductID_RoleFullLevel;
}
else if (unitID >= ID_Magic_Start && unitID <= ID_Magic_End) {
//SdkManager::getInstance()->pay(ProductID_MagicFullLevel);
product_id = ProductID_MagicFullLevel;
}
else {
CCASSERT(false, "error!");
}
//test win32
#if DEBUG_ALWAYS_BUY_SUCCESS == 1
EventDispatcher * eventDspc = Director::getInstance()->getEventDispatcher();
EventCustom event(MSG_PayResult);
MsgData data;
data.value = product_id;
data.errorCode = Rsp_Success;
event.setUserData(&data);
eventDspc->dispatchEvent(&event);
#endif
}
void GameLayer::registerEventHandlers() {
Director* director = Director::getInstance();
EventDispatcher* eventDispatcher = director->getEventDispatcher();
EventListenerTouchOneByOne* eventListener = EventListenerTouchOneByOne::create();
eventListener->setSwallowTouches(true);
eventListener->onTouchEnded = [=](Touch* touch, Event* event){
if (!getAcceptInput()) {
return;
}
Vec2 position = m_tileLayer->convertTouchToNodeSpace(touch);
for (auto iterator = m_tileLayer->getChildren().begin(); iterator != m_tileLayer->getChildren().end(); iterator++) {
auto child = *iterator;
GameTileView* gameTileView = dynamic_cast<GameTileView*>(child);
if(gameTileView->getBoundingBox().containsPoint(position)) {
if (gameTileView->getGameTile()->getCanMove()) {
doSelectGameTileView(gameTileView);
}
break;
}
}
};
eventListener->onTouchBegan = [](Touch* touch, Event* event){
return true;
};
eventListener->onTouchMoved = [](Touch* touch, Event* event){};
eventListener->onTouchCancelled = [](Touch* touch, Event* event){};
eventDispatcher->addEventListenerWithSceneGraphPriority(eventListener, m_tileLayer);
}
int main()
{
EventDispatcher dispatcher;
int my_var = 0;
dispatcher.addHandler("event1", [&my_var](EventDispatcher& ev) -> bool {
cout << "My event1 has been launched (first handler)" << endl;
my_var++;
return true;
});
dispatcher.addHandler("event1", [&my_var](EventDispatcher& ev) -> bool {
cout << "My event1 has been launched (second handler)" << endl;
my_var++;
cout << "Trigger event2..." << endl;
ev.dispatchEvent("event2");
return false;
});
dispatcher.addHandler("event2", [&my_var](EventDispatcher& ev) -> bool {
cout << "My event2 has been launched!" << endl;
my_var++;
return true;
});
cout << "Triggering event..." << endl;
dispatcher.dispatchEvent("event1");
cout << "My var is: " << my_var << endl;
return 0;
}
int EventDispatcherBinder::hasEventListener(lua_State* L)
{
StackChecker checker(L, "EventDispatcherBinder::hasEventListener", 1);
Binder binder(L);
EventDispatcher* eventDispatcher = static_cast<EventDispatcher*>(binder.getInstance("EventDispatcher"));
luaL_checktype(L, 2, LUA_TSTRING);
if (eventDispatcher->data(&key_map) == NULL)
{
lua_pushboolean(L, 0);
}
else
{
EventBinderMap& map = *static_cast<EventBinderMap*>(eventDispatcher->data(&key_map));
const char* event = lua_tostring(L, 2);
int eventid = StringId::instance().id(event);
const std::vector<CppLuaBridge*>& bridges = map[eventid];
lua_pushboolean(L, bridges.empty() ? 0 : 1);
}
return 1;
}
/// \brief Define the main() for the point entry
int main(int argc, char *argv[])
{
int returnCode;
QApplication ultracopierApplication(argc, argv);
ultracopierApplication.setApplicationVersion(ULTRACOPIER_VERSION);
ultracopierApplication.setQuitOnLastWindowClosed(false);
qRegisterMetaType<PluginsAvailable>("PluginsAvailable");
qRegisterMetaType<Ultracopier::DebugLevel>("Ultracopier::DebugLevel");
qRegisterMetaType<Ultracopier::CopyMode>("Ultracopier::CopyMode");
qRegisterMetaType<Ultracopier::ItemOfCopyList>("Ultracopier::ItemOfCopyList");
#ifdef ULTRACOPIER_DEBUG
DebugEngine::getInstance();
#endif // ULTRACOPIER_DEBUG
//the main code, event loop of Qt and event dispatcher of ultracopier
{
EventDispatcher backgroundRunningInstance;
if(backgroundRunningInstance.shouldBeClosed())
returnCode=0;
else
returnCode=ultracopierApplication.exec();
}
#ifdef ULTRACOPIER_DEBUG
DebugEngine::destroyInstanceAtTheLastCall();
#endif // ULTRACOPIER_DEBUG
return returnCode;
}
void Stage::OnChar(wxKeyEvent &inEvent) {
if (!ShouldSendEvents()) {
inEvent.Skip();
} else if (inEvent.GetKeyCode() == WXK_ESCAPE) {
// The menu accelerator for StageFrame::OnStopMovies doesn't appear
// to work in wxWidgets 2.9 (and maybe also 2.8). If the
// accelerator doesn't work, we currently receive the escape key
// event here. (We tried calling inEvent.Skip and passing this up
// to a handle on the StageFrame, but the event never arrived,
// possibly because StageFrame is not configured to receive key
// events.)
EndMediaElements();
} else if (inEvent.GetKeyCode() == WXK_SPACE &&
inEvent.ControlDown() && !inEvent.AltDown()) {
inEvent.Skip(); // Always allow toggling into edit mode.
} else {
// NOTE - We process character events directed at the Stage here,
// but the Stage isn't always focused. Is this really a good idea?
// Douglas tells me that Director works like this, so at least
// there's precedent.
EventDispatcher *dispatcher = GetEventDispatcher();
if (!dispatcher->DoEventChar(inEvent))
inEvent.Skip();
}
}
int main()
{
/*shared_ptr<Foobar> ptrShared(new Foobar);
weak_ptr<Foobar> ptrWeak(ptrShared);
cout<<"weak_ptr valid:"<<(!ptrWeak.expired() ? "true" : "false")<<endl;
shared_ptr<Foobar> ptrShared1 = ptrWeak.lock();
ptrShared = nullptr;
cout<<"weak_ptr valid:"<<(!ptrWeak.expired() ? "true" : "false")<<endl;*/
EventDispatcher *dispatcher = new EventDispatcher;
//vector<EventConnectionHolder> eventConnHolderPool;
//eventConnHolderPool.push_back(dispatcher->subscribeEvent());
EventConnectionHolder connectionHolder;
connectionHolder = dispatcher->subscribeEvent();
EventSlot slot(std::move(connectionHolder));
//dispatcher->subscribeEvent();
//EventSlot slot = dispatcher->subscribeEvent();
//EventConnectionHolder connectionHolder(dispatcher->subscribeEvent());
/*for(auto &holder : eventConnHolderPool)
{
holder.disconnect();
}*/
//connectionHolder.disconnect();
delete dispatcher;
return 0;
}
int EventDispatcherBinder::dispatchEvent(lua_State* L)
{
StackChecker checker(L, "EventDispatcherBinder::dispatchEvent", 0);
Binder binder(L);
EventDispatcher* eventDispatcher = static_cast<EventDispatcher*>(binder.getInstance("EventDispatcher", 1));
luaL_checktype(L, 2, LUA_TTABLE);
// lua_getfield(L, 2, "type");
lua_getfield(L, 2, "getType");
lua_pushvalue(L, 2);
lua_call(L, 1, 1);
std::string event = luaL_checkstring(L, -1);
lua_pop(L, 1);
LuaEvent e = LuaEvent(LuaEvent::Type(event.c_str()));
LuaApplication *application = (LuaApplication*)luaL_getdata(L);
lua_State *mainL = application->getLuaState();
lua_pushvalue(L, 2); // push event to main thread
if (mainL != L)
lua_xmove(L, mainL, 1);
eventDispatcher->dispatchEvent(&e);
lua_pop(mainL, 1); // pop event from main thread
return 0;
}
bool WorkerEventQueue::cancelEvent(Event& event)
{
EventDispatcher* task = m_eventDispatcherMap.take(&event);
if (!task)
return false;
task->cancel();
return true;
}
int EventDispatcherBinder::destruct(lua_State* L)
{
void* ptr = *(void**)lua_touserdata(L, 1);
EventDispatcher* eventDispatcher = static_cast<EventDispatcher*>(ptr);
eventDispatcher->unref();
return 0;
}
void Widget::FocusNavigationController::removeKeyboardEventListener()
{
if (nullptr != _keyboardListener)
{
EventDispatcher* dispatcher = Director::getInstance()->getEventDispatcher();
dispatcher->removeEventListener(_keyboardListener);
_keyboardListener = nullptr;
}
}
/*static*/
status_t
EventDispatcher::_cursor_looper(void* _dispatcher)
{
EventDispatcher* dispatcher = (EventDispatcher*)_dispatcher;
ETRACE(("Start cursor loop\n"));
dispatcher->_CursorLoop();
return B_OK;
}
/*static*/
status_t
EventDispatcher::_event_looper(void* _dispatcher)
{
EventDispatcher* dispatcher = (EventDispatcher*)_dispatcher;
ETRACE(("Start event loop\n"));
dispatcher->_EventLoop();
return B_OK;
}
void Widget::FocusNavigationController::addKeyboardEventListener()
{
if (nullptr == _keyboardListener)
{
_keyboardListener = EventListenerKeyboard::create();
_keyboardListener->onKeyReleased = CC_CALLBACK_2(Widget::FocusNavigationController::onKeypadKeyPressed, this);
EventDispatcher* dispatcher = Director::getInstance()->getEventDispatcher();
dispatcher->addEventListenerWithFixedPriority(_keyboardListener, _keyboardEventPriority);
}
}
TEST(EventDispatcher, Timer) {
using namespace std::placeholders;
EventDispatcher dispatcher;
bool received = false;
TimerEventWatcher watcher(&dispatcher, std::bind(OnTimer, &received, _1),
200);
watcher.Start();
dispatcher.Run();
EXPECT_TRUE(received);
}
TEST(EventDispatcher, Signal) {
using namespace std::placeholders;
EventDispatcher dispatcher;
bool received = false;
SignalEventWatcher watcher(&dispatcher, std::bind(OnSignal, &dispatcher,
&received, _1), SIGALRM);
watcher.Start();
alarm(1);
dispatcher.Run();
EXPECT_TRUE(received);
}
bool PauseLayer::init()
{
if (!AlertLayer::init())
{
return false;
}
auto board = this->getBoard();
auto title = Sprite::createWithSpriteFrameName(s_pause_txt);
title->setPosition(Vec2(board->getContentSize().width / 2, board->getContentSize().height));
board->addChild(title);
// 继续按钮
auto resumeSprite = Sprite::createWithSpriteFrameName(s_resume_btn);
auto resumeSpriteActive = Sprite::createWithSpriteFrameName(s_resume_btn_a);
auto resumeItem = MenuItemSprite::create(resumeSprite, resumeSpriteActive,
CC_CALLBACK_1(PauseLayer::resumeCallBack, this));
resumeItem->setAnchorPoint(Vec2::ZERO);
resumeItem->setScale(0.7f);
resumeItem->setPosition(Vec2(40, 50));
// 重开按钮
auto restartSprite = Sprite::createWithSpriteFrameName(s_restart_btn);
auto restartSpriteActive = Sprite::createWithSpriteFrameName(s_restart_btn_a);
auto restartItem = MenuItemSprite::create(restartSprite, restartSpriteActive,
CC_CALLBACK_1(PauseLayer::restartCallBack, this));
restartItem->setAnchorPoint(Vec2::ZERO);
restartItem->setScale(0.7f);
restartItem->setPosition(Vec2(140, 50));
// 回首页按钮
auto goHomeSprite = Sprite::createWithSpriteFrameName(s_go_home_btn);
auto goHomeSpriteActive= Sprite::createWithSpriteFrameName(s_go_home_btn_a);
auto goHomeItem = MenuItemSprite::create(goHomeSprite, goHomeSpriteActive,
CC_CALLBACK_1(PauseLayer::goHomeCallBack, this));
goHomeItem->setAnchorPoint(Vec2::ZERO);
goHomeItem->setScale(0.7f);
goHomeItem->setPosition(Vec2(240, 50));
auto menu = Menu::create(resumeItem, restartItem, goHomeItem, NULL);
menu->setPosition(Vec2::ZERO);
board->addChild(menu);
EventDispatcher *eventDispatcher = Director::getInstance()->getEventDispatcher();
auto listener = EventListenerTouchOneByOne::create();
listener->setSwallowTouches(true); // 是否吞掉事件让下面的层无法响应
listener->onTouchBegan = CC_CALLBACK_2(PauseLayer::onTouchBegan, this);
listener->onTouchMoved = CC_CALLBACK_2(PauseLayer::onTouchMoved, this);
listener->onTouchEnded = CC_CALLBACK_2(PauseLayer::onTouchEnded, this);
eventDispatcher->addEventListenerWithSceneGraphPriority(listener, this);
return true;
}
ASFUNCTIONBODY(NativeApplication, addEventListener)
{
EventDispatcher* th = Class<EventDispatcher>::cast(obj);
EventDispatcher::addEventListener(obj, args, argslen);
if (args[0]->toString() == "invoke")
{
th->incRef();
getVm()->addEvent(_MR(th), _MR(Class<InvokeEvent>::getInstanceS()));
}
return NULL;
}
void ChatScene::setEventHadlers()
{
EventDispatcher* pDispatcher = Director::getInstance()->getEventDispatcher();
EventListenerTouchOneByOne* pEventListener = EventListenerTouchOneByOne::create();
pEventListener->setSwallowTouches(true);
pEventListener->onTouchBegan = CC_CALLBACK_2(ChatScene::onTouchBegan, this);
pEventListener->onTouchMoved = CC_CALLBACK_2(ChatScene::onTouchMoved, this);
pEventListener->onTouchEnded = CC_CALLBACK_2(ChatScene::onTouchEnded, this);
pDispatcher->addEventListenerWithSceneGraphPriority(pEventListener, this);
}
bool EventDispatcher::DispatchEvent(Element* target_element, const String& name, const Dictionary& parameters, bool interruptible)
{
//Event event(target_element, name, parameters, interruptible);
Event* event = Factory::InstanceEvent(target_element, name, parameters, interruptible);
if (event == NULL)
return false;
// Build the element traversal from the tree
typedef std::vector<Element*> Elements;
Elements elements;
Element* walk_element = target_element->GetParentNode();
while (walk_element)
{
elements.push_back(walk_element);
walk_element = walk_element->GetParentNode();
}
event->SetPhase(Event::PHASE_CAPTURE);
// Capture phase - root, to target (only events that have registered as capture events)
// Note: We walk elements in REVERSE as they're placed in the list from the elements parent to the root
for (int i = elements.size() - 1; i >= 0 && event->IsPropagating(); i--)
{
EventDispatcher* dispatcher = elements[i]->GetEventDispatcher();
event->SetCurrentElement(elements[i]);
dispatcher->TriggerEvents(event);
}
// Target phase - direct at the target
if (event->IsPropagating())
{
event->SetPhase(Event::PHASE_TARGET);
event->SetCurrentElement(target_element);
TriggerEvents(event);
}
if (event->IsPropagating())
{
event->SetPhase(Event::PHASE_BUBBLE);
// Bubble phase - target to root (normal event bindings)
for (size_t i = 0; i < elements.size() && event->IsPropagating(); i++)
{
EventDispatcher* dispatcher = elements[i]->GetEventDispatcher();
event->SetCurrentElement(elements[i]);
dispatcher->TriggerEvents(event);
}
}
bool propagating = event->IsPropagating();
event->RemoveReference();
return propagating;
}
void Stage::OnLeftDown(wxMouseEvent &inEvent) {
// Restore focus to the stage (or our game engine, if it's on top).
if (GameEngineIsDisplayed())
GameEngineSetFocus();
else
SetFocus();
// Dispatch the event.
if (ShouldSendEvents()) {
EventDispatcher *disp = FindEventDispatcher(inEvent.GetPosition());
disp->DoEventLeftDown(inEvent, false);
}
}
TEST(EventDispatcher, Io) {
using namespace std::placeholders;
EventDispatcher dispatcher;
char c = 0;
int fd = open("/dev/zero", O_RDONLY, 0666);
ASSERT_NE(-1, fd);
IoEventWatcher watcher(&dispatcher, std::bind(OnIo, fd, &c, _1),
fd, EventMask_Read);
watcher.Start();
dispatcher.RunOnce();
close(fd);
EXPECT_EQ(0, c);
}
void GameLayer::registerHandler(Node* node, std::function<void(Touch*, Event*)> onTouchEnded) {
Director* director = Director::getInstance();
EventDispatcher* eventDispatcher = director->getEventDispatcher();
EventListenerTouchOneByOne* eventListener = EventListenerTouchOneByOne::create();
eventListener->setSwallowTouches(true);
eventListener->onTouchEnded = onTouchEnded;
eventListener->onTouchBegan = [](Touch* touch, Event* event){
return true;
};
eventDispatcher->addEventListenerWithSceneGraphPriority(eventListener, node);
}
//-------------------------------------------------------------------------------------
void EventDispatcher::attachTo(EventDispatcher & parentDispatcher)
{
KBE_ASSERT(pCouplingToParent_ == NULL);
pCouplingToParent_ = new DispatcherCoupling(parentDispatcher, *this);
int fd = pPoller_->getFileDescriptor();
if (fd != -1)
{
parentDispatcher.registerFileDescriptor(fd, pPoller_);
parentDispatcher.registerWriteFileDescriptor(fd, pPoller_);
}
}
bool SceneGame::init()
{
if (!Layer::init())
{
return false;
}
Size visibleSize = Director::getInstance()->getVisibleSize();
Vec2 origin = Director::getInstance()->getVisibleOrigin();
_c = new std::vector<Chess*>();
_c->resize(1000);
_steps = new std::vector<Step*>();
_steps->reserve(1000);
createPlate();
Chess::_d = Director::getInstance()->getWinSize().height / 10;
Chess::_offx = Chess::_d;
Chess::_offy = Chess::_d / 2;
for (int i = 0; i < 32; i++)
{
_c->at(i) = Chess::create();
_c->at(i)->initChess(i);
addChild(_c->at(i));
}
EventDispatcher *eventDispatcher = Director::getInstance()->getEventDispatcher();
auto listener = EventListenerTouchOneByOne::create();
listener->onTouchBegan = CC_CALLBACK_2(SceneGame::onTouchBegan, this);
listener->onTouchEnded = CC_CALLBACK_2(SceneGame::onTouchEnd, this);
eventDispatcher->addEventListenerWithSceneGraphPriority(listener, this);
_selectid = 1;
_selectSprite = Sprite::create("selected.png");
_selectSprite->setVisible(false);
addChild(_selectSprite);
_selectSprite->setScale(0.6f);
_selectSprite->setZOrder(100);
_bRedTurn = true;
_steps->clear();
addCtrlPanel();
return true;
}
DispatchEventResult MouseEventDispatchMediator::dispatchEvent(
EventDispatcher& dispatcher) const {
MouseEvent& mouseEvent = event();
mouseEvent.eventPath().adjustForRelatedTarget(dispatcher.node(),
mouseEvent.relatedTarget());
if (!mouseEvent.isTrusted())
return dispatcher.dispatch();
if (isDisabledFormControl(&dispatcher.node()))
return DispatchEventResult::CanceledBeforeDispatch;
if (mouseEvent.type().isEmpty())
return DispatchEventResult::NotCanceled; // Shouldn't happen.
DCHECK(!mouseEvent.target() ||
mouseEvent.target() != mouseEvent.relatedTarget());
EventTarget* relatedTarget = mouseEvent.relatedTarget();
DispatchEventResult dispatchResult = dispatcher.dispatch();
if (mouseEvent.type() != EventTypeNames::click || mouseEvent.detail() != 2)
return dispatchResult;
// Special case: If it's a double click event, we also send the dblclick
// event. This is not part of the DOM specs, but is used for compatibility
// with the ondblclick="" attribute. This is treated as a separate event in
// other DOM-compliant browsers like Firefox, and so we do the same.
MouseEvent* doubleClickEvent = MouseEvent::create();
doubleClickEvent->initMouseEventInternal(
EventTypeNames::dblclick, mouseEvent.bubbles(), mouseEvent.cancelable(),
mouseEvent.view(), mouseEvent.detail(), mouseEvent.screenX(),
mouseEvent.screenY(), mouseEvent.clientX(), mouseEvent.clientY(),
mouseEvent.modifiers(), mouseEvent.button(), relatedTarget,
mouseEvent.sourceCapabilities(), mouseEvent.buttons());
doubleClickEvent->setComposed(mouseEvent.composed());
// Inherit the trusted status from the original event.
doubleClickEvent->setTrusted(mouseEvent.isTrusted());
if (mouseEvent.defaultHandled())
doubleClickEvent->setDefaultHandled();
DispatchEventResult doubleClickDispatchResult =
EventDispatcher::dispatchEvent(
dispatcher.node(),
MouseEventDispatchMediator::create(doubleClickEvent));
if (doubleClickDispatchResult != DispatchEventResult::NotCanceled)
return doubleClickDispatchResult;
return dispatchResult;
}
//-------------------------------------------------------------------------------------
void EventDispatcher::detachFrom(EventDispatcher & parentDispatcher)
{
int fd = pPoller_->getFileDescriptor();
if (fd != -1)
{
parentDispatcher.deregisterFileDescriptor(fd);
parentDispatcher.deregisterWriteFileDescriptor(fd);
}
KBE_ASSERT(pCouplingToParent_ != NULL);
delete pCouplingToParent_;
pCouplingToParent_ = NULL;
}
void Rolelayer::spcall(Node* node,bool mr){
Layer* p=(Layer*)this->getChildByTag(shop_layertag);
p->setPosition(Vec2(Actual_x,0));
EventDispatcher * eventDspc = Director::getInstance()->getEventDispatcher();
EventCustom event(Topmsg_ch);
MsgData data;
data.value =2;
event.setUserData(&data);
eventDspc->dispatchEvent(&event);
}
