void translateKeyDownEvent(const SDL_Event& event)
{
SDL_Keysym keysym = event.key.keysym;
// ALT+RETURN = Fullscreen toggle
if (keysym.sym == SDLK_RETURN && (keysym.mod & KMOD_LALT))
{
PPEvent myEvent(eFullScreen);
RaiseEventSerialized(&myEvent);
return;
}
preTranslateKey(keysym);
#ifdef DEBUG
printf ("DEBUG: Key pressed: VK: %d, SC: %d, Scancode: %d\n", toVK(keysym), toSC(keysym), keysym.sym);
#endif
pp_uint16 chr[3] = {toVK(keysym), toSC(keysym), keysym.sym};
#ifndef NOT_PC_KB
// Hack for azerty keyboards (num keys are shifted, so we use the scancodes)
if (stdKb)
{
if (chr[1] >= 2 && chr[1] <= 10)
chr[0] = chr[1] + 47; // 1-9
else if (chr[1] == 11)
chr[0] = 48; // 0
}
#endif
PPEvent myEvent(eKeyDown, &chr, sizeof(chr));
RaiseEventSerialized(&myEvent);
}
void translateMouseMoveEvent(pp_int32 mouseButton, pp_int32 localMouseX, pp_int32 localMouseY)
{
myDisplayDevice->transform(localMouseX, localMouseY);
p.x = localMouseX;
p.y = localMouseY;
if (mouseButton == 0)
{
p.x = localMouseX; p.y = localMouseY;
PPEvent myEvent(eMouseMoved, &p, sizeof(PPPoint));
RaiseEventSerialized(&myEvent);
}
else
{
if (mouseButton > 2 || !mouseButton)
return;
p.x = localMouseX; p.y = localMouseY;
if (mouseButton == 1 && lMouseDown)
{
PPEvent myEvent(eLMouseDrag, &p, sizeof(PPPoint));
RaiseEventSerialized(&myEvent);
}
else if (rMouseDown)
{
PPEvent myEvent(eRMouseDrag, &p, sizeof(PPPoint));
RaiseEventSerialized(&myEvent);
}
}
}
void processSDLUserEvents(const SDL_UserEvent& event)
{
union {
void *ptr;
pp_int32 i32;
} data1, data2;
data1.ptr = event.data1;
data2.ptr = event.data2;
switch (event.code)
{
case SDLUserEventTimer:
{
PPEvent myEvent(eTimer);
RaiseEventSerialized(&myEvent);
break;
}
case SDLUserEventLMouseRepeat:
{
PPPoint p;
p.x = data1.i32;
p.y = data2.i32;
PPEvent myEvent(eLMouseRepeat, &p, sizeof(PPPoint));
RaiseEventSerialized(&myEvent);
break;
}
case SDLUserEventRMouseRepeat:
{
PPPoint p;
p.x = data1.i32;
p.y = data2.i32;
PPEvent myEvent(eRMouseRepeat, &p, sizeof(PPPoint));
RaiseEventSerialized(&myEvent);
break;
}
case SDLUserEventMidiKeyDown:
{
pp_int32 note = data1.i32;
pp_int32 volume = data2.i32;
globalMutex->lock();
myTracker->sendNoteDown(note, volume);
globalMutex->unlock();
break;
}
case SDLUserEventMidiKeyUp:
{
pp_int32 note = data1.i32;
globalMutex->lock();
myTracker->sendNoteUp(note);
globalMutex->unlock();
break;
}
}
}
//---------------------------------------------------------------------------------------
void WelcomeWindow::OnInstructions(wxHyperlinkEvent& event)
{
// wxString sDoc = "study-guide.htm";
// ShowDocument(sDoc);
wxCommandEvent myEvent(wxEVT_COMMAND_MENU_SELECTED, k_menu_help_study_guide);
::wxPostEvent(this, myEvent);
}
//---------------------------------------------------------------------------------------
void WelcomeWindow::OnQuickGuide(wxHyperlinkEvent& event)
{
// wxString sDoc = "editor_quick_guide.htm";
// ShowDocument(sDoc);
wxCommandEvent myEvent(wxEVT_COMMAND_MENU_SELECTED, k_menu_help_editor_quick);
::wxPostEvent(this, myEvent);
}
vector<y60::EventPtr> DSADriver::poll()
{
vector<y60::EventPtr> myEvents;
for (SensorServerList::iterator ssli = _mySensorServers.begin();
ssli != _mySensorServers.end(); ++ssli) {
SensorServer::SensorData mySensorData;
ssli->second->poll(mySensorData);
for (SensorArrayList::iterator sali = _mySensorArray.begin();
sali != _mySensorArray.end(); ++sali) {
std::vector<asl::Vector2i> myRawEvents;
for(SensorServer::SensorData::iterator sdi = mySensorData.begin();
sdi != mySensorData.end(); ++sdi) {
if (sali->second->getGridSize()[0] == 0 &&
sali->second->getGridSize()[1] == 0)
{
// TODO: Raw Events for multiple Ports
sali->second->createRawEvents(myRawEvents,
ssli->first, // thePortId
sdi->first, // theControllerId
sdi->second // theBitMask
);
} else {
sali->second->createCookedEvents(myRawEvents,
ssli->first, // thePortId
sdi->first, // theControllerId
sdi->second // theBitMask
);
}
}
for (unsigned int i = 0; i < myRawEvents.size(); ++i) {
asl::Vector2f myPosition((float)myRawEvents[i][0], (float)myRawEvents[i][1]);
unsigned int myCount = 1;
// interpolate neighboring events
if (_myInterpolateFlag) {
for (unsigned int j = 0; j < myRawEvents.size(); ++j) {
if (i == j) {
continue;
}
asl::Vector2i myDelta = asl::difference(myRawEvents[j], myRawEvents[i]);
if (magnitude(myDelta) <= 1) {
myPosition += asl::Vector2f((float)myRawEvents[j][0], (float)myRawEvents[j][1]);
myCount++;
}
}
if (myCount > 1) {
myPosition = product(myPosition, 1.0f / float(myCount));
AC_TRACE << "DSADriver: interpolated distance " << myPosition << "," << myCount;
}
}
y60::EventPtr myEvent(new y60::TouchEvent(sali->second->getName(), myPosition, sali->second->getGridSize(), float(myCount)));
myEvents.push_back(myEvent);
}
}
}
return myEvents;
}
void WebkitPixelStreamer::processKeyRelease(const deflect::Event &keyEvent)
{
QKeyEvent myEvent(QEvent::KeyRelease, keyEvent.key,
(Qt::KeyboardModifiers)keyEvent.modifiers,
QString::fromStdString(keyEvent.text)
);
webView_.page()->event(&myEvent);
}
void WebkitPixelStreamer::processReleaseEvent(const deflect::Event &releaseEvent)
{
const QPoint& pointerPos = getPointerPosition(releaseEvent);
QMouseEvent myEvent(QEvent::MouseButtonRelease, pointerPos,
Qt::LeftButton, Qt::LeftButton,
(Qt::KeyboardModifiers)releaseEvent.modifiers);
webView_.page()->event(&myEvent);
interactionModeActive_ = false;
}
void translateKeyDownEvent(const SDL_Event& event)
{
SDL_keysym keysym = event.key.keysym;
// ALT+RETURN = Fullscreen toggle
if (keysym.sym == SDLK_RETURN && (keysym.mod & KMOD_LALT))
{
PPEvent myEvent(eFullScreen);
RaiseEventSerialized(&myEvent);
return;
}
preTranslateKey(keysym);
pp_uint16 character = event.key.keysym.unicode;
pp_uint16 chr[3] = {toVK(keysym), toSC(keysym), character};
#ifndef NOT_PC_KB
// Hack for azerty keyboards (num keys are shifted, so we use the scancodes)
if (stdKb)
{
if (chr[1] >= 2 && chr[1] <= 10)
chr[0] = chr[1] + 47; // 1-9
else if (chr[1] == 11)
chr[0] = 48; // 0
}
#endif
PPEvent myEvent(eKeyDown, &chr, sizeof(chr));
RaiseEventSerialized(&myEvent);
if(character == 127) character = VK_BACK;
if (character >= 32 && character <= 127)
{
PPEvent myEvent2(eKeyChar, &character, sizeof(character));
RaiseEventSerialized(&myEvent2);
}
}
void WebkitPixelStreamer::processWheelEvent(const deflect::Event &wheelEvent)
{
const QWebHitTestResult& hitResult = performHitTest(wheelEvent);
if(!hitResult.isNull() && isWebGLElement(hitResult.element()))
{
const int delta = wheelEvent.dy;
QWheelEvent myEvent(hitResult.pos(), delta, Qt::NoButton,
(Qt::KeyboardModifiers)wheelEvent.modifiers,
Qt::Vertical);
webView_.page()->event(&myEvent);
}
}
void translateMouseWheelEvent(pp_int32 wheelX, pp_int32 wheelY) {
TMouseWheelEventParams mouseWheelParams;
// Deltas from wheel event
mouseWheelParams.deltaX = wheelX;
mouseWheelParams.deltaY = wheelY;
// Use last stored coordinates
mouseWheelParams.pos.x = p.x;
mouseWheelParams.pos.y = p.y;
PPEvent myEvent(eMouseWheelMoved, &mouseWheelParams, sizeof(mouseWheelParams));
RaiseEventSerialized(&myEvent);
}
void translateTextInputEvent(const SDL_Event& event)
{
#ifdef DEBUG
printf ("DEBUG: Text input: %s\n", event.text.text);
#endif
char character = event.text.text[0];
// Only deal with ASCII characters
if (character >= 32 && character <= 127)
{
PPEvent myEvent(eKeyChar, &character, sizeof(character));
RaiseEventSerialized(&myEvent);
}
}
void WebkitPixelStreamer::processPressEvent(const deflect::Event &pressEvent)
{
const QWebHitTestResult& hitResult = performHitTest(pressEvent);
if(hitResult.isNull() || isWebGLElement(hitResult.element()))
{
interactionModeActive_ = true;
}
const QPoint& pointerPos = getPointerPosition(pressEvent);
QMouseEvent myEvent(QEvent::MouseButtonPress, pointerPos,
Qt::LeftButton, Qt::LeftButton,
(Qt::KeyboardModifiers)pressEvent.modifiers);
webView_.page()->event(&myEvent);
}
void
CInputFilter::handleEvent(const CEvent& event, void*)
{
// copy event and adjust target
CEvent myEvent(event.getType(), this, event.getData(),
event.getFlags() | CEvent::kDontFreeData |
CEvent::kDeliverImmediately);
// let each rule try to match the event until one does
for (CRuleList::iterator rule = m_ruleList.begin();
rule != m_ruleList.end(); ++rule) {
if (rule->handleEvent(myEvent)) {
// handled
return;
}
}
// not handled so pass through
EVENTQUEUE->addEvent(myEvent);
}
void translateKeyUpEvent(const SDL_Event& event)
{
SDL_Keysym keysym = event.key.keysym;
preTranslateKey(keysym);
pp_uint16 chr[3] = {toVK(keysym), toSC(keysym), keysym.sym};
#ifndef NOT_PC_KB
if (stdKb)
{
if(chr[1] >= 2 && chr[1] <= 10)
chr[0] = chr[1] + 47;
else if(chr[1] == 11)
chr[0] = 48;
}
#endif
PPEvent myEvent(eKeyUp, &chr, sizeof(chr));
RaiseEventSerialized(&myEvent);
}
int myCreateEvent(Ndb* myNdb,
const char *eventName,
const char *eventTableName,
const char **eventColumnNames,
const int noEventColumnNames,
bool merge_events)
{
NdbDictionary::Dictionary *myDict= myNdb->getDictionary();
if (!myDict) APIERROR(myNdb->getNdbError());
const NdbDictionary::Table *table= myDict->getTable(eventTableName);
if (!table) APIERROR(myDict->getNdbError());
NdbDictionary::Event myEvent(eventName, *table);
myEvent.addTableEvent(NdbDictionary::Event::TE_ALL);
// myEvent.addTableEvent(NdbDictionary::Event::TE_INSERT);
// myEvent.addTableEvent(NdbDictionary::Event::TE_UPDATE);
// myEvent.addTableEvent(NdbDictionary::Event::TE_DELETE);
myEvent.addEventColumns(noEventColumnNames, eventColumnNames);
myEvent.mergeEvents(merge_events);
// Add event to database
if (myDict->createEvent(myEvent) == 0)
myEvent.print();
else if (myDict->getNdbError().classification ==
NdbError::SchemaObjectExists) {
printf("Event creation failed, event exists\n");
printf("dropping Event...\n");
if (myDict->dropEvent(eventName)) APIERROR(myDict->getNdbError());
// try again
// Add event to database
if ( myDict->createEvent(myEvent)) APIERROR(myDict->getNdbError());
} else
APIERROR(myDict->getNdbError());
return 0;
}
void WebkitPixelStreamer::processMoveEvent(const deflect::Event &moveEvent)
{
const QPoint& pointerPos = getPointerPosition(moveEvent);
if( interactionModeActive_ )
{
QMouseEvent myEvent(QEvent::MouseMove, pointerPos,
Qt::LeftButton, Qt::LeftButton,
(Qt::KeyboardModifiers)moveEvent.modifiers);
webView_.page()->event(&myEvent);
}
else
{
QWebFrame *pFrame = webView_.page()->frameAt(pointerPos);
if (!pFrame)
return;
int dx = moveEvent.dx * webView_.page()->viewportSize().width();
int dy = moveEvent.dy * webView_.page()->viewportSize().height();
pFrame->scroll(-dx,-dy);
}
}
//---------------------------------------------------------------------------------------
void WelcomeWindow::OnOpenEBooks(wxHyperlinkEvent& event)
{
wxCommandEvent myEvent(wxEVT_COMMAND_MENU_SELECTED, k_menu_open_books);
::wxPostEvent(this, myEvent);
}
//---------------------------------------------------------------------------------------
void WelcomeWindow::OnOpenRecent(wxHyperlinkEvent& event)
{
int i = event.GetId() - lmLINK_Recent1;
wxCommandEvent myEvent(wxEVT_COMMAND_MENU_SELECTED, wxID_FILE1+i);
::wxPostEvent(this, myEvent);
}
void translateMouseUpEvent(pp_int32 mouseButton, pp_int32 localMouseX, pp_int32 localMouseY)
{
if (mouseButton > 2 || !mouseButton)
return;
myDisplayDevice->transform(localMouseX, localMouseY);
p.x = localMouseX;
p.y = localMouseY;
// -----------------------------
if (mouseButton == 1)
{
lClickCount++;
if (lClickCount >= 4)
{
pp_uint32 deltat = PPGetTickCount() - lmyTime;
if (deltat < 500)
{
p.x = localMouseX; p.y = localMouseY;
if (abs(p.x - llastClickPosition.x) < 4 &&
abs(p.y - llastClickPosition.y) < 4)
{
PPEvent myEvent(eLMouseDoubleClick, &p, sizeof(PPPoint));
RaiseEventSerialized(&myEvent);
}
}
lClickCount = 0;
}
p.x = localMouseX; p.y = localMouseY;
PPEvent myEvent(eLMouseUp, &p, sizeof(PPPoint));
RaiseEventSerialized(&myEvent);
lMouseDown = false;
}
else if (mouseButton == 2)
{
rClickCount++;
if (rClickCount >= 4)
{
pp_uint32 deltat = PPGetTickCount() - rmyTime;
if (deltat < 500)
{
p.x = localMouseX; p.y = localMouseY;
if (abs(p.x - rlastClickPosition.x) < 4 &&
abs(p.y - rlastClickPosition.y) < 4)
{
PPEvent myEvent(eRMouseDoubleClick, &p, sizeof(PPPoint));
RaiseEventSerialized(&myEvent);
}
}
rClickCount = 0;
}
p.x = localMouseX; p.y = localMouseY;
PPEvent myEvent(eRMouseUp, &p, sizeof(PPPoint));
RaiseEventSerialized(&myEvent);
rMouseDown = false;
}
}
void translateMouseDownEvent(pp_int32 mouseButton, pp_int32 localMouseX, pp_int32 localMouseY)
{
if (mouseButton > 2 || !mouseButton)
return;
myDisplayDevice->transform(localMouseX, localMouseY);
p.x = localMouseX;
p.y = localMouseY;
// -----------------------------
if (mouseButton == 1)
{
PPEvent myEvent(eLMouseDown, &p, sizeof(PPPoint));
RaiseEventSerialized(&myEvent);
lMouseDown = true;
lButtonDownStartTime = timerTicker;
if (!lClickCount)
{
lmyTime = PPGetTickCount();
llastClickPosition.x = localMouseX;
llastClickPosition.y = localMouseY;
}
else if (lClickCount == 2)
{
pp_uint32 deltat = PPGetTickCount() - lmyTime;
if (deltat > 500)
{
lClickCount = 0;
lmyTime = PPGetTickCount();
llastClickPosition.x = localMouseX;
llastClickPosition.y = localMouseY;
}
}
lClickCount++;
}
else if (mouseButton == 2)
{
PPEvent myEvent(eRMouseDown, &p, sizeof(PPPoint));
RaiseEventSerialized(&myEvent);
rMouseDown = true;
rButtonDownStartTime = timerTicker;
if (!rClickCount)
{
rmyTime = PPGetTickCount();
rlastClickPosition.x = localMouseX;
rlastClickPosition.y = localMouseY;
}
else if (rClickCount == 2)
{
pp_uint32 deltat = PPGetTickCount() - rmyTime;
if (deltat > 500)
{
rClickCount = 0;
rmyTime = PPGetTickCount();
rlastClickPosition.x = localMouseX;
rlastClickPosition.y = localMouseY;
}
}
rClickCount++;
}
}
void
WMTouchPlugin::onTouch(HWND hWnd, WPARAM wParam, LPARAM lParam) {
BOOL bHandled = FALSE;
UINT cInputs = LOWORD(wParam);
PTOUCHINPUT pInputs = new TOUCHINPUT[cInputs];
if (GetTouchInputInfo((HTOUCHINPUT)lParam, cInputs, pInputs, sizeof(TOUCHINPUT))){
AC_DEBUG << "found " << cInputs << " Cursors!";
for (UINT i=0; i < cInputs; i++){
const TOUCHINPUT & ti = pInputs[i];
// create a y60 event for each InputInfo
GenericEventPtr myEvent(new GenericEvent("onWMTouch", _myEventSchemaDocument, _myEventValueFactory));
NodePtr myNode = myEvent->getNode();
asl::Vector2f myPosition = product(Vector2f(static_cast<float>(ti.x), static_cast<float>(ti.y)), 0.01f);
asl::Vector2f myCalibratedRelativePosition = asl::Vector2f(0.0, 0.0);
float myWidth = _calibrationPositionTopRight[0] - _calibrationPositionBottomLeft[0];
float myHeight = _calibrationPositionTopRight[1] - _calibrationPositionBottomLeft[1];
if (myWidth != 0) {
myCalibratedRelativePosition[0] = (myPosition[0] - _calibrationPositionBottomLeft[0]) / myWidth;
}
if (myHeight != 0) {
myCalibratedRelativePosition[1] = (myPosition[1] - _calibrationPositionBottomLeft[1]) / myHeight;
}
myNode->appendAttribute<int>("id", ti.dwID);
myNode->appendAttribute<Vector2f>("position", myPosition);
myNode->appendAttribute<Vector2f>("calibrated_relative_position", myCalibratedRelativePosition);
if (ti.dwMask & TOUCHINPUTMASKF_CONTACTAREA) {
myNode->appendAttribute<Vector2f>("contactarea", product(Vector2f(static_cast<float>(ti.cxContact), static_cast<float>(ti.cyContact)), 0.01f));
}
myNode->appendAttribute<bool>("inrange", (ti.dwFlags & TOUCHEVENTF_INRANGE) != 0);
myNode->appendAttribute<bool>("primary", (ti.dwFlags & TOUCHEVENTF_PRIMARY) != 0);
myNode->appendAttribute<bool>("nocoalesce", (ti.dwFlags & TOUCHEVENTF_NOCOALESCE) != 0);
myNode->appendAttribute<bool>("palm", (ti.dwFlags & TOUCHEVENTF_PALM) != 0);
// Note: we seem to be getting duplicate events, probably due to the way we are hooking the msg queue.
// So we filter the events here. Only queue a DOWN event if the cursor wasn't down yet,
// and only queue an UP or MOVE event if the cursor was down.
if ((ti.dwFlags & TOUCHEVENTF_DOWN) != 0 && _downCursors.find(ti.dwID) == _downCursors.end()) {
myNode->appendAttribute<DOMString>("type", "down");
_queuedEvents.push_back(myEvent);
_downCursors.insert(ti.dwID);
} else if ((ti.dwFlags & TOUCHEVENTF_UP) != 0 && _downCursors.find(ti.dwID) != _downCursors.end()) {
myNode->appendAttribute<DOMString>("type", "up");
_queuedEvents.push_back(myEvent);
_downCursors.erase(ti.dwID);
} else if ((ti.dwFlags & TOUCHEVENTF_MOVE) != 0 && _downCursors.find(ti.dwID) != _downCursors.end()) {
_queuedEvents.push_back(myEvent);
myNode->appendAttribute<DOMString>("type", "move");
}
}
bHandled = TRUE;
}else{
/* handle the error here */
AC_ERROR << errorDescription(lastError());
}
// clean up
delete [] pInputs;
if (bHandled){
// if you handled the message, close the touch input handle and return
CloseTouchInputHandle((HTOUCHINPUT)lParam);
return;
}
};
static
int
createEvent(Ndb *pNdb,
const NdbDictionary::Table &tab,
bool merge_events = true,
bool report = true)
{
char eventName[1024];
sprintf(eventName,"%s_EVENT",tab.getName());
NdbDictionary::Dictionary *myDict = pNdb->getDictionary();
if (!myDict) {
g_err << "Dictionary not found "
<< pNdb->getNdbError().code << " "
<< pNdb->getNdbError().message << endl;
return NDBT_FAILED;
}
myDict->dropEvent(eventName);
NdbDictionary::Event myEvent(eventName);
myEvent.setTable(tab.getName());
myEvent.addTableEvent(NdbDictionary::Event::TE_ALL);
for(int a = 0; a < tab.getNoOfColumns(); a++) {
myEvent.addEventColumn(a);
}
myEvent.mergeEvents(merge_events);
if (report)
myEvent.setReport(NdbDictionary::Event::ER_SUBSCRIBE);
int res = myDict->createEvent(myEvent); // Add event to database
if (res == 0)
myEvent.print();
else if (myDict->getNdbError().classification ==
NdbError::SchemaObjectExists)
{
g_info << "Event creation failed event exists\n";
res = myDict->dropEvent(eventName);
if (res) {
g_err << "Failed to drop event: "
<< myDict->getNdbError().code << " : "
<< myDict->getNdbError().message << endl;
return NDBT_FAILED;
}
// try again
res = myDict->createEvent(myEvent); // Add event to database
if (res) {
g_err << "Failed to create event (1): "
<< myDict->getNdbError().code << " : "
<< myDict->getNdbError().message << endl;
return NDBT_FAILED;
}
}
else
{
g_err << "Failed to create event (2): "
<< myDict->getNdbError().code << " : "
<< myDict->getNdbError().message << endl;
return NDBT_FAILED;
}
return NDBT_OK;
}
void translateMouseUpEvent(pp_int32 mouseButton, pp_int32 localMouseX, pp_int32 localMouseY)
{
myDisplayDevice->transform(localMouseX, localMouseY);
if (mouseButton == SDL_BUTTON_WHEELDOWN)
{
TMouseWheelEventParams mouseWheelParams;
mouseWheelParams.pos.x = localMouseX;
mouseWheelParams.pos.y = localMouseY;
mouseWheelParams.delta = -1;
PPEvent myEvent(eMouseWheelMoved, &mouseWheelParams, sizeof(mouseWheelParams));
RaiseEventSerialized(&myEvent);
}
else if (mouseButton == SDL_BUTTON_WHEELUP)
{
TMouseWheelEventParams mouseWheelParams;
mouseWheelParams.pos.x = localMouseX;
mouseWheelParams.pos.y = localMouseY;
mouseWheelParams.delta = 1;
PPEvent myEvent(eMouseWheelMoved, &mouseWheelParams, sizeof(mouseWheelParams));
RaiseEventSerialized(&myEvent);
}
else if (mouseButton > 2 || !mouseButton)
return;
// -----------------------------
if (mouseButton == 1)
{
lClickCount++;
if (lClickCount >= 4)
{
pp_uint32 deltat = PPGetTickCount() - lmyTime;
if (deltat < 500)
{
p.x = localMouseX; p.y = localMouseY;
if (abs(p.x - llastClickPosition.x) < 4 &&
abs(p.y - llastClickPosition.y) < 4)
{
PPEvent myEvent(eLMouseDoubleClick, &p, sizeof(PPPoint));
RaiseEventSerialized(&myEvent);
}
}
lClickCount = 0;
}
p.x = localMouseX; p.y = localMouseY;
PPEvent myEvent(eLMouseUp, &p, sizeof(PPPoint));
RaiseEventSerialized(&myEvent);
lMouseDown = false;
}
else if (mouseButton == 2)
{
rClickCount++;
if (rClickCount >= 4)
{
pp_uint32 deltat = PPGetTickCount() - rmyTime;
if (deltat < 500)
{
p.x = localMouseX; p.y = localMouseY;
if (abs(p.x - rlastClickPosition.x) < 4 &&
abs(p.y - rlastClickPosition.y) < 4)
{
PPEvent myEvent(eRMouseDoubleClick, &p, sizeof(PPPoint));
RaiseEventSerialized(&myEvent);
}
}
rClickCount = 0;
}
p.x = localMouseX; p.y = localMouseY;
PPEvent myEvent(eRMouseUp, &p, sizeof(PPPoint));
RaiseEventSerialized(&myEvent);
rMouseDown = false;
}
}