void mouseScrollBy(double x, double y, bool continuous)
{
RECT rect;
::GetWindowRect(webViewWindow, &rect);
// This value is taken from Source/WebCore/platform/win/WheelEventWin.cpp
const float cScrollbarPixelsPerLine = 100.0f / 3.0f;
if (x) {
UINT scrollChars = 1;
::SystemParametersInfo(SPI_GETWHEELSCROLLCHARS, 0, &scrollChars, 0);
x *= WHEEL_DELTA / scrollChars;
if (continuous)
x /= cScrollbarPixelsPerLine;
MSG msg = makeMsg(webViewWindow, WM_MOUSEHWHEEL, MAKEWPARAM(0, x), MAKELPARAM(rect.left + lastMousePosition.x, rect.top + lastMousePosition.y));
dispatchMessage(&msg);
}
if (y) {
UINT scrollLines = 3;
::SystemParametersInfo(SPI_GETWHEELSCROLLLINES, 0, &scrollLines, 0);
y *= WHEEL_DELTA / scrollLines;
if (continuous)
y /= cScrollbarPixelsPerLine;
MSG msg = makeMsg(webViewWindow, WM_MOUSEWHEEL, MAKEWPARAM(0, y), MAKELPARAM(rect.left + lastMousePosition.x, rect.top + lastMousePosition.y));
dispatchMessage(&msg);
}
}
void StateCook::enter(Entity *entity)
{
Entity *husband = EntityFactory::getInstance()->getEntity("husband");
auto instance = tinycraft::MessageDispatcher<Entity>::getInstance();
instance->dispatchMessage(entity, husband, "getup");
instance->dispatchMessage(entity, entity, "havebreakfast", nullptr, 5);
instance->dispatchMessage(entity, husband, "havebreakfast", nullptr, 5);
}
static JSValueRef contextClickCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
{
COMPtr<IWebFramePrivate> framePrivate;
if (SUCCEEDED(frame->QueryInterface(&framePrivate)))
framePrivate->layout();
down = true;
MSG msg = makeMsg(webViewWindow, WM_RBUTTONDOWN, 0, MAKELPARAM(lastMousePosition.x, lastMousePosition.y));
dispatchMessage(&msg);
down = false;
msg = makeMsg(webViewWindow, WM_RBUTTONUP, 0, MAKELPARAM(lastMousePosition.x, lastMousePosition.y));
dispatchMessage(&msg);
return JSValueMakeUndefined(context);
}
void Connection::dispatchMessage(std::unique_ptr<MessageDecoder> message)
{
// If there's no client, return. We do this after calling releaseArguments so that
// the ArgumentDecoder message will be freed.
if (!m_client)
return;
m_inDispatchMessageCount++;
if (message->shouldDispatchMessageWhenWaitingForSyncReply())
m_inDispatchMessageMarkedDispatchWhenWaitingForSyncReplyCount++;
bool oldDidReceiveInvalidMessage = m_didReceiveInvalidMessage;
m_didReceiveInvalidMessage = false;
if (message->isSyncMessage())
dispatchSyncMessage(*message);
else
dispatchMessage(*message);
m_didReceiveInvalidMessage |= message->isInvalid();
m_inDispatchMessageCount--;
if (message->shouldDispatchMessageWhenWaitingForSyncReply())
m_inDispatchMessageMarkedDispatchWhenWaitingForSyncReplyCount--;
if (m_didReceiveInvalidMessage && m_client)
m_client->didReceiveInvalidMessage(this, message->messageReceiverName(), message->messageName());
m_didReceiveInvalidMessage = oldDidReceiveInvalidMessage;
}
void flush()
{
ENetEvent event;
// Check if there are any new events
while (enet_host_service(client, &event, 0) > 0)
{
switch (event.type)
{
case ENET_EVENT_TYPE_CONNECT:
logger->log("Connected to port %d.", event.peer->address.port);
// Store any relevant server information here.
event.peer->data = 0;
break;
case ENET_EVENT_TYPE_RECEIVE:
dispatchMessage(event.packet);
break;
case ENET_EVENT_TYPE_DISCONNECT:
logger->log("Disconnected.");
// Reset the server information.
event.peer->data = 0;
break;
case ENET_EVENT_TYPE_NONE:
default:
break;
}
}
}
void flush()
{
ENetEvent event;
// Wait up to 10 milliseconds for an event.
while (enet_host_service(client, &event, 10) > 0)
{
switch (event.type)
{
case ENET_EVENT_TYPE_CONNECT:
logger->log("Connected to port %d.", event.peer->address.port);
// Store any relevant server information here.
event.peer->data = 0;
break;
case ENET_EVENT_TYPE_RECEIVE:
dispatchMessage(event.packet);
break;
case ENET_EVENT_TYPE_DISCONNECT:
logger->log("Disconnected.");
// Reset the server information.
event.peer->data = 0;
break;
case ENET_EVENT_TYPE_NONE:
logger->log("No event during 10 milliseconds.");
break;
default:
logger->log("Unhandled enet event.");
break;
}
}
}
void main()
{
int i,j,boxidx;
int driver=DETECT, mode=0;
randomize();
//registerbgidriver(EGAVGA_driver);
initgraph(&driver,&mode,"");
xyz:
do
{
menu();
init();
boxidx=random(7);
FORCOLOR2=random(7)+1;
for(j=0;j<4;j++)
for(i=0;i<4;i++)
box2[j][i]=BOX[boxidx][j][i];
do
{
getMessage();
dispatchMessage();
}while(!gameOver());
highscore();
OVER();
getch();
}while(1);
}
void OSCPacketDispatcher::dispatchPacket(OSCPacket& packet, QHostAddress& address, QDateTime* timestamp)
{
if(packet.isBundle)
{
dispatchBundle((OSCBundle&)packet, address);
}else
{
if(timestamp)
{
dispatchMessage((OSCMessage&)packet, address, *timestamp);
}else
{
dispatchMessage((OSCMessage&)packet, address);
}
}
}
static void doMouseMove(MSG msg)
{
COMPtr<IWebFramePrivate> framePrivate;
if (SUCCEEDED(frame->QueryInterface(&framePrivate)))
framePrivate->layout();
dispatchMessage(&msg);
if (down && draggingInfo) {
POINT screenPoint = msg.pt;
::ClientToScreen(webViewWindow, &screenPoint);
IWebView* webView;
COMPtr<IDropTarget> webViewDropTarget;
if (SUCCEEDED(frame->webView(&webView)) && SUCCEEDED(webView->QueryInterface(IID_IDropTarget, (void**)&webViewDropTarget))) {
DWORD effect = 0;
if (didDragEnter)
webViewDropTarget->DragOver(MK_LBUTTON, pointl(screenPoint), &effect);
else {
webViewDropTarget->DragEnter(draggingInfo->dataObject(), 0, pointl(screenPoint), &effect);
didDragEnter = true;
}
draggingInfo->dropSource()->GiveFeedback(effect);
}
}
}
static void doMouseUp(MSG msg)
{
COMPtr<IWebFramePrivate> framePrivate;
if (SUCCEEDED(frame->QueryInterface(&framePrivate)))
framePrivate->layout();
dispatchMessage(&msg);
down = false;
if (draggingInfo) {
COMPtr<IWebView> webView;
COMPtr<IDropTarget> webViewDropTarget;
if (SUCCEEDED(frame->webView(&webView)) && SUCCEEDED(webView->QueryInterface(IID_IDropTarget, (void**)&webViewDropTarget))) {
POINT screenPoint = msg.pt;
::ClientToScreen(webViewWindow, &screenPoint);
HRESULT hr = draggingInfo->dropSource()->QueryContinueDrag(0, 0);
DWORD effect = 0;
webViewDropTarget->DragOver(0, pointl(screenPoint), &effect);
if (hr == DRAGDROP_S_DROP && effect != DROPEFFECT_NONE) {
DWORD effect = 0;
webViewDropTarget->Drop(draggingInfo->dataObject(), 0, pointl(screenPoint), &effect);
} else
webViewDropTarget->DragLeave();
delete draggingInfo;
draggingInfo = 0;
}
}
}
//
// file descriptor callback
//
int
EventHandler::handle_input (ACE_HANDLE fd)
{
unsigned char thisChar;
// buffer for bytes send form the panTilt
unsigned char buff[BUFFSIZE];
int buffPos = 0;
int buffLen = 0;
buffLen = read(fd,buff,BUFFSIZE);
if (buffLen < -1) {
throw Miro::Exception("EventHandler::handle_input: Error on file descriptor");
} else if (buffLen == 0) {
throw Miro::Exception("EventHandler::handle_input: fd was called, but 0 bytes for reading");
} else {
buffPos = 0;
}
while (buffPos < buffLen) {
thisChar = buff[ buffPos++ ];
// cerr << "[" << (unsigned int)(thisChar) << "]" << flush;
switch(state) {
case WFSTAR:
if (thisChar == '*') {
state = WFDELIM;
msg_->time() = ACE_OS::gettimeofday(); // set time stamp
}
else if (thisChar == '!') {
state = WFDELIM;
msg_->setErrorState();
}
else {
cerr << "ignoring :|" << thisChar << "|" << endl;
}
break;
case WFDELIM:
if (thisChar == '\n') {
state = WFSTAR;
dispatchMessage();
msg_->resetMessage();
}
else {
//cerr << "using :|" << thisChar << "|" << endl;
// TODO here append to message
msg_->addChar( thisChar );
}
break;
default:
throw Miro::Exception("EventHandler::handle_input: unknown state in panTiltEvent.");
break;
}
}
return 0;
}
void CookieDatabaseBackingStore::getCookiesFromDatabase(Vector<ParsedCookie*>& stackOfCookies, unsigned int limit)
{
// It is not a huge performance hit to wait on the reply here because this is only done once during setup and when turning off private mode.
TypedReplyBuffer< Vector<ParsedCookie*>* > replyBuffer(0);
dispatchMessage(createMethodCallMessageWithReturn(&CookieDatabaseBackingStore::invokeGetCookiesWithLimit, &replyBuffer, this, limit));
Vector<ParsedCookie*>* cookies = replyBuffer.pointer();
stackOfCookies.swap(*cookies);
delete cookies;
}
void NetworkProcessProxy::didReceiveMessage(CoreIPC::Connection* connection, CoreIPC::MessageDecoder& decoder)
{
if (dispatchMessage(connection, decoder))
return;
if (m_webContext->dispatchMessage(connection, decoder))
return;
didReceiveNetworkProcessProxyMessage(connection, decoder);
}
void NetworkProcessProxy::didReceiveMessage(IPC::Connection& connection, IPC::MessageDecoder& decoder)
{
if (dispatchMessage(connection, decoder))
return;
if (m_processPool.dispatchMessage(connection, decoder))
return;
didReceiveNetworkProcessProxyMessage(connection, decoder);
}
void handleWindowEvents(FrameworkWindow *window, long signalSet) {
struct IntuiMessage *msg;
struct Window *iwindow = window->intuitionWindow;
if(1L << iwindow->UserPort->mp_SigBit & signalSet) {
while(msg = GT_GetIMsg(iwindow->UserPort)) {
dispatchMessage(window, msg);
GT_ReplyIMsg(msg);
}
}
handleWindowChildEvents(window, signalSet);
}
void StateGetup::enter(Entity *entity)
{
std::cout << entity->getName() << ": tring to get up." << std::endl;
void *data = malloc(6);
memset(data, 0, 6);
memcpy(data, "pasta", 5);
Entity *wife = EntityFactory::getInstance()->getEntity("wife");
auto instance = tinycraft::MessageDispatcher<Entity>::getInstance();
instance->dispatchMessage(entity, wife, "hungry", data, 3);
}
void Connection::dispatchOneMessage()
{
std::unique_ptr<MessageDecoder> message;
{
MutexLocker locker(m_incomingMessagesLock);
if (m_incomingMessages.isEmpty())
return;
message = m_incomingMessages.takeFirst();
}
dispatchMessage(std::move(message));
}
void MRJSession::idle(UInt32 milliseconds)
{
// Each call to idle processes a single message.
dispatchMessage();
#if !TARGET_CARBON
// Guard against entering the VM multiple times.
if (mLockCount == 0) {
lock();
mStatus = ::JMIdle(mSession, milliseconds);
unlock();
}
#endif
}
void WebProcessProxy::didReceiveMessage(IPC::Connection* connection, IPC::MessageDecoder& decoder)
{
if (dispatchMessage(connection, decoder))
return;
if (m_context->dispatchMessage(connection, decoder))
return;
if (decoder.messageReceiverName() == Messages::WebProcessProxy::messageReceiverName()) {
didReceiveWebProcessProxyMessage(connection, decoder);
return;
}
// FIXME: Add unhandled message logging.
}
void RCDataCenter::parseProtoLoginReq(ProtoLoginReq* req)
{
CCLog("req : %i", req->authid());
ProtoLoginRes* res = new ProtoLoginRes();
res->set_mapid(1);
RCMessageStruct* messageStruct = new RCMessageStruct();
messageStruct->messageCode = MC_PROTOLOGINRES;
res->SerializeToArray(messageStruct->data, res->ByteSize());
int size = res->ByteSize() + sizeof(messageStruct->messageCode);
dispatchMessage(messageStruct, size);
delete (messageStruct);
delete (res);
}
// Function listening and captures data sends to client,
void MainWindow::readTcpData()
{
Message msg;
QByteArray data = connectionManager->readAll();
qDebug()<<"readTcp: " + data;
msg.decode(data);
// msg.setTimestamp();
dispatchMessage(msg);
// if(msg.from == myProfile->login) {
// connect(this, SIGNAL(sendMessage(Message)), this, SLOT(recognitionMessage(Message)));
// emit sendMessage(msg);
// }
}
void BFMailBox::dataReceived(QByteArray *pData)
{
mMessageBuffer.append(*pData);
const MessageHead* pHead = (const MessageHead*)mMessageBuffer.constData();
while (pHead->length <= pData->length()) {
QByteArray message = QByteArray::fromRawData(mMessageBuffer.constData(), pHead->length);
dispatchMessage(pHead->type, &message);
mMessageBuffer.remove(0, pHead->length);
if (mMessageBuffer.size() < sizeof(MessageHead))
break;
pHead = (const MessageHead*)mMessageBuffer.constData();
}
}
static JSValueRef mouseDownCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
{
COMPtr<IWebFramePrivate> framePrivate;
if (SUCCEEDED(frame->QueryInterface(&framePrivate)))
framePrivate->layout();
down = true;
int mouseType = WM_LBUTTONDOWN;
if (argumentCount >= 1) {
int mouseNumber = JSValueToNumber(context, arguments[0], exception);
switch (mouseNumber) {
case 0:
mouseType = WM_LBUTTONDOWN;
break;
case 1:
mouseType = WM_MBUTTONDOWN;
break;
case 2:
mouseType = WM_RBUTTONDOWN;
break;
case 3:
// fast/events/mouse-click-events expects the 4th button has event.button = 1, so send an WM_BUTTONDOWN
mouseType = WM_MBUTTONDOWN;
break;
default:
mouseType = WM_LBUTTONDOWN;
break;
}
}
WPARAM wparam = 0;
if (argumentCount >= 2)
wparam |= buildModifierFlags(context, arguments[1]);
MSG msg = makeMsg(webViewWindow, mouseType, wparam, MAKELPARAM(lastMousePosition.x, lastMousePosition.y));
if (!msgQueue[endOfQueue].delay)
dispatchMessage(&msg);
else {
// replaySavedEvents has the required logic to make leapForward delays work
msgQueue[endOfQueue++].msg = msg;
replaySavedEvents();
}
return JSValueMakeUndefined(context);
}
static JSValueRef mouseDownCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
{
COMPtr<IWebFramePrivate> framePrivate;
if (SUCCEEDED(frame->QueryInterface(&framePrivate)))
framePrivate->layout();
down = true;
MSG msg = makeMsg(webViewWindow, WM_LBUTTONDOWN, 0, MAKELPARAM(lastMousePosition.x, lastMousePosition.y));
if (!msgQueue[endOfQueue].delay)
dispatchMessage(&msg);
else {
// replaySavedEvents has the required logic to make leapForward delays work
msgQueue[endOfQueue++].msg = msg;
replaySavedEvents();
}
return JSValueMakeUndefined(context);
}
void World::update()
{
bool worldchanged = false;
while(MsgMngr.hasMoreMessages())
{
Message msg = MsgMngr.peekMessage();
MsgMngr.dispatch();
std::cout << "dispatching message: ";
for(std::map<std::string,std::string>::iterator i = msg.map.begin();i!=msg.map.end();i++)
{
std::cout << i->first << " " << i->second << " ";
}
std::cout << "\n";
dispatchMessage(msg);
worldchanged = true;
}
if(worldchanged)
{
updateInfobox();
}
}
// Create new conversation tab
// Insert or add new tab in CBD and add connect signal to slot
void MainWindow::addNewTab(QString to)
{
QString login;
QSqlQuery q("SELECT login FROM contacts WHERE alias='"+to+"';", contactsDb);
if(q.next()) {
login = q.value("login").toString();
}else
return;
openChatBox();
ChatBoxDialogContent *newContent = new ChatBoxDialogContent();
newContent->myProfile = myProfile;
createdTabs->insert(to, newContent);
form->insertTab(to.toInt(), createdTabs->take(to), to);
newContent->receiver = login;
connect(newContent, SIGNAL(sendMessage(Message)), this, SLOT(dispatchMessage(Message)));
form->setCurrentIndex(to.toInt());
form->activateWindow();
}
// file descriptor callback
int
EventHandler::handle_input (ACE_HANDLE fd)
{
MIRO_DBG(SPARROW, LL_PRATTLE, "Can::EventHandler: handle_input()");
int count;
if(params_->module == "pcan"){
pcanmsg * msgp;
msg_->canMessage((int **) &msgp);
count = ioctl(fd, PCAN_READ_MSG, msgp);
if (count < 0) {
MIRO_LOG(LL_ERROR, "Pcan handle_input() failed!");
return 0;
}
}
else {
canmsg * msg;
msg_->canMessage((int **) &msg);
count = ACE_OS::read(fd, msg, sizeof(canmsg));
if (count == 0) {
MIRO_LOG(LL_WARNING,
"Can::EventHandler: handle_input() called with no data!");
return 0;
}
if (count != sizeof(canmsg)) {
MIRO_LOG_OSTR(LL_ERROR,
"Can::EventHandler: read() != sizeof(canmsg): " <<
count << " != " << sizeof(canmsg));
return 0;
}
}
msg_->time() = ACE_OS::gettimeofday(); // set time stamp
dispatchMessage();
return 0;
}
void checkForInputs(CheckDataSet data)
{
Buffer workExchangeBuffer; // use a copy to keep the size
workExchangeBuffer.pointer = data.exchangeBuffer->pointer;
while(1)
{
data.container->containerMutex->lock();
data.container->selector->wait(sf::milliseconds(100)); // waits for data, 100ms timeout (give a chance to unlock other threads)
for(int i = 0 ; i < data.container->list->getSize() ; i++)
{
if(data.container->list->get(i)->isReady &&
data.container->selector->isReady(*data.container->list->get(i)->socket))
{
if(receiveBuffer(data.container->list->get(i)->socket,&workExchangeBuffer,data.exchangeBuffer->size))
{
logger.printLog("Client disconnected !");
killClient(data.container,i);
}
if(workExchangeBuffer.size > 0)
{
logger.printDebug("Got data, dispatching");
dispatchMessage(data.container,&workExchangeBuffer,i);
}
}
}
data.container->containerMutex->unlock();
if(checkStopThreads())
{
return;
}
sf::sleep(sf::milliseconds(1)); // give time for the other threads
}
}
static void doMouseUp(MSG msg, HRESULT* oleDragAndDropReturnValue = 0)
{
COMPtr<IWebFramePrivate> framePrivate;
if (SUCCEEDED(frame->QueryInterface(&framePrivate)))
framePrivate->layout();
dispatchMessage(&msg);
down = false;
if (draggingInfo) {
COMPtr<IWebView> webView;
COMPtr<IDropTarget> webViewDropTarget;
if (SUCCEEDED(frame->webView(&webView)) && SUCCEEDED(webView->QueryInterface(IID_IDropTarget, (void**)&webViewDropTarget))) {
POINT screenPoint = msg.pt;
DWORD effect = 0;
::ClientToScreen(webViewWindow, &screenPoint);
if (!didDragEnter) {
webViewDropTarget->DragEnter(draggingInfo->dataObject(), 0, pointl(screenPoint), &effect);
didDragEnter = true;
}
HRESULT hr = draggingInfo->dropSource()->QueryContinueDrag(0, 0);
if (oleDragAndDropReturnValue)
*oleDragAndDropReturnValue = hr;
webViewDropTarget->DragOver(0, pointl(screenPoint), &effect);
if (hr == DRAGDROP_S_DROP && effect != DROPEFFECT_NONE) {
DWORD effect = 0;
webViewDropTarget->Drop(draggingInfo->dataObject(), 0, pointl(screenPoint), &effect);
draggingInfo->setPerformedDropEffect(effect);
} else
webViewDropTarget->DragLeave();
// Reset didDragEnter so that another drag started within the same frame works properly.
didDragEnter = false;
}
}
}
void CInputHandler::processMessage(CMessage *msg) {
const CMouseMsg *mouseMsg = dynamic_cast<const CMouseMsg *>(msg);
_singleton = false;
dispatchMessage(msg);
if (_singleton) {
_singleton = false;
} else if (mouseMsg) {
// Keep the game state mouse position up to date
if (_mousePos != mouseMsg->_mousePos) {
_mousePos = mouseMsg->_mousePos;
_gameManager->_gameState.setMousePos(mouseMsg->_mousePos);
}
// Set flag for whether a mouse button is currently being pressed
if (mouseMsg->isButtonDownMsg())
_buttonDown = true;
else if (mouseMsg->isButtonUpMsg())
_buttonDown = false;
// Drag events generation
if (_dragging) {
if (mouseMsg->isMouseMoveMsg()) {
if (_dragItem) {
CMouseDragMoveMsg moveMsg(_mousePos);
moveMsg.execute(_dragItem);
}
} else {
if (mouseMsg->isButtonUpMsg() && _dragItem) {
// Mouse drag ended
CGameObject *target = dragEnd(_mousePos, _dragItem);
CMouseDragEndMsg endMsg(_mousePos, target);
endMsg.execute(_dragItem);
}
_dragging = false;
_dragItem = nullptr;
}
} else if (_buttonDown) {
if (!mouseMsg->isMouseMoveMsg()) {
// Save where the drag movement started from
_dragStartPos = _mousePos;
} else {
Point delta = mouseMsg->_mousePos - _dragStartPos;
int distance = (int)sqrt(double(delta.x * delta.x + delta.y * delta.y));
if (distance > 4) {
// We've moved far enough with the mouse button held down
// to trigger an official dragging operation
CMouseDragStartMsg startMsg(_dragStartPos);
dispatchMessage(&startMsg);
// Set the drag item, if any, that a handler will have set on the message
_dragItem = startMsg._dragItem;
_gameManager->_dragItem = startMsg._dragItem;
if (_dragItem) {
CMouseDragMoveMsg moveMsg(_dragStartPos);
dispatchMessage(&moveMsg);
}
_dragging = true;
}
}
}
}
}
