void InputProcessor::Enable(bool enable)
{
if (IsEnabled() == enable)
return;
Keyboard *keyboard = m_gameApp->GetKeyboard();
Mouse *mouse = m_gameApp->GetMouse();
Touchscreen *touchscreen = m_gameApp->GetTouchscreen();
if (enable)
{
if (keyboard != NULL)
keyboard->RegisterListener(this);
if (mouse != NULL)
mouse->RegisterListener(this);
if (touchscreen != NULL)
touchscreen->RegisterListener(this);
}
else
{
if (keyboard != NULL)
keyboard->UnregisterListener(this);
if (mouse != NULL)
mouse->UnregisterListener(this);
if (touchscreen != NULL)
touchscreen->UnregisterListener(this);
}
m_enabled = enable;
}
virtual bool onMouseUp(const Mouse& m){
// cache for rendering
x = m.x(); y = m.y();
// send to audio thread:
audio_inbox.send(setfreq, this, x / width(), 1. - y/height());
return true;
}
bool ex_sync (void *arg) {
char* name = "client.pipeline";
RunAsThread client (runSyncClient, name, true);
client.start ();
TheFramework *frame = ssi_pcast (TheFramework, Factory::GetFramework ());
frame->getOptions ()->sync = true;
frame->getOptions ()->sport = 9999;
frame->getOptions ()->slisten = false;
/*
frame->getOptions ()->setMonitorPos (0,0,400,200);
frame->getOptions ()->setConsolePos (800, 200, 400, 200);
*/
Mouse *mouse = ssi_create (Mouse, 0, false);
mouse->getOptions ()->sr = 5.0;
ITransformable *cursor_p = frame->AddProvider (mouse, SSI_MOUSE_CURSOR_PROVIDER_NAME);
frame->AddSensor (mouse);
SocketWriter *writer = ssi_create (SocketWriter, 0, true);
writer->getOptions ()->type = Socket::UDP;
writer->getOptions ()->port = 9998;
frame->AddConsumer (cursor_p, writer, "1");
frame->Start ();
frame->Wait ();
frame->Stop ();
frame->Clear ();
client.stop ();
return true;
}
//! [0]
int main(int argc, char **argv)
{
QApplication app(argc, argv);
qsrand(QTime(0,0,0).secsTo(QTime::currentTime()));
//! [0]
//! [1]
QGraphicsScene scene;
scene.setSceneRect(-300, -300, 600, 600);
//! [1] //! [2]
scene.setItemIndexMethod(QGraphicsScene::NoIndex);
//! [2]
//! [3]
for (int i = 0; i < MouseCount; ++i) {
Mouse *mouse = new Mouse;
mouse->setPos(::sin((i * 6.28) / MouseCount) * 200,
::cos((i * 6.28) / MouseCount) * 200);
scene.addItem(mouse);
}
//! [3]
//! [4]
GraphicsView view(&scene);
view.setRenderHint(QPainter::Antialiasing);
view.setBackgroundBrush(QPixmap(":/images/cheese.jpg"));
//! [4] //! [5]
view.setCacheMode(QGraphicsView::CacheBackground);
view.setViewportUpdateMode(QGraphicsView::BoundingRectViewportUpdate);
//! [5] //! [6]
view.setWindowTitle(QT_TRANSLATE_NOOP(QGraphicsView, "Colliding Mice"));
view.showMaximized();
return app.exec();
}
bool ex_diff(void *args)
{
ITheFramework *frame = Factory::GetFramework();
Decorator *decorator = ssi_create(Decorator, 0, true);
frame->AddDecorator(decorator);
Mouse *mouse = ssi_create(Mouse, 0, true);
mouse->getOptions()->mask = Mouse::LEFT;
ITransformable *cursor_t = frame->AddProvider(mouse, SSI_MOUSE_CURSOR_PROVIDER_NAME);
frame->AddSensor(mouse);
PythonFilter *py_diff = ssi_create(PythonFilter, 0, true);
py_diff->getOptions()->setScript("ssi_diff");
ITransformable *py_diff_t = frame->AddTransformer(cursor_t, py_diff, "0.1s");
SignalPainter *plot = 0;
plot = ssi_create_id(SignalPainter, 0, "plot");
plot->getOptions()->setTitle("DIFF (PYTHON)");
plot->getOptions()->size = 10;
frame->AddConsumer(py_diff_t, plot, "1");
decorator->add("console", 0, 0, 650, 800);
decorator->add("plot*", 650, 0, 400, 400);
decorator->add("monitor*", 650, 400, 400, 400);
frame->Start();
frame->Wait();
frame->Stop();
frame->Clear();
return true;
}
int main(int /*argc*/, char* /*argv*/[]) {
const float t = 1.0f; // duration of the test in seconds
const float dt = 0.02f; // intervals between updates in seconds
Mouse *mouse = new Mouse(); cout << "> mouse allocated." << endl;
if (!mouse->init()) ERROR
cout << "> mouse initialized." << endl;
const int N = (int)ceilf(t / dt);
const long secs = (int) floorf(dt);
const long nanos = (long) (1000000000L * fmodf(dt, 1.0f));
mouse->grab();
cout << "> mouse grabbed." << endl;
for (int i=0; i<N; i++) {
mouse->update();
cout << "pos = (" << mouse->xPos() << "," << mouse->yPos() << ") "
<< "buttons = " << mouse->isPressed(Mouse::LEFT) << "," << mouse->isPressed(Mouse::MIDDLE) << "," << mouse->isPressed(Mouse::RIGHT)
<< endl;
struct timespec t = { secs, nanos };
nanosleep(&t, NULL);
}
mouse->ungrab();
cout << "> mouse ungrabbed." << endl;
mouse->close();
cout << "> mouse acquisition closed." << endl;
return 0;
}
bool ex_print(void *args)
{
ITheFramework *frame = Factory::GetFramework();
Decorator *decorator = ssi_create(Decorator, 0, true);
frame->AddDecorator(decorator);
Mouse *mouse = ssi_create(Mouse, 0, true);
mouse->getOptions()->mask = Mouse::LEFT;
ITransformable *button_t = frame->AddProvider(mouse, SSI_MOUSE_BUTTON_PROVIDER_NAME);
ITransformable *cursor_t = frame->AddProvider(mouse, SSI_MOUSE_CURSOR_PROVIDER_NAME);
frame->AddSensor(mouse);
PythonConsumer *py_print = ssi_create(PythonConsumer, 0, true);
py_print->getOptions()->setScript("ssi_print");
ITransformable *input[] = { button_t, cursor_t };
//py_print->getOptions()->add("path", "result.txt");
frame->AddConsumer(2, input, py_print, "100ms");
decorator->add("console", 0, 0, 650, 800);
decorator->add("plot*", 650, 0, 400, 400);
decorator->add("monitor*", 650, 400, 400, 400);
frame->Start();
frame->Wait();
frame->Stop();
frame->Clear();
return true;
}
void DraggingOperation(Mouse event)
{
/*
* prevx and prevy are updated everytime the mouse is pressed down, not while it's pressed
*/
if (isDragging == true)
{
// get mouse's coordinates
int x = event.GetX();
int y = event.GetY();
// get client's window size
int w = 0, h = 0;
GetClientSize(&w, &h);
float xangle = (prevy - y) * 360.0f / w;
float yangle = (x- prevx) * 360.0f / h;
sth->rotX(xangle);
sth->rotY(yangle);
prevx = x;
prevy = y;
Refresh();
}
}
//------------------------------------
// Cliquer sur la souris
void MouseEvent(int button, int state, int x, int y)
{
if(button == 0 && state == 1)
mouse.leftclick(world,button);
if(button == 2 && state == 1)
mouse.rightclick(world,button,choice+page);
}
bool ex_clone(void *args)
{
ITheFramework *frame = Factory::GetFramework();
Decorator *decorator = ssi_create(Decorator, 0, true);
frame->AddDecorator(decorator);
Mouse *mouse = ssi_create(Mouse, 0, true);
mouse->getOptions()->mask = Mouse::LEFT;
ITransformable *button_t = frame->AddProvider(mouse, SSI_MOUSE_BUTTON_PROVIDER_NAME);
ITransformable *cursor_t = frame->AddProvider(mouse, SSI_MOUSE_CURSOR_PROVIDER_NAME);
frame->AddSensor(mouse);
PythonTransformer *clone = 0;
clone = ssi_create(PythonTransformer, 0, true);
clone->getOptions()->setScript("ssi_clone");
ITransformable *button_clone_t = frame->AddTransformer(button_t, clone, "0.1s");
clone = ssi_create(PythonTransformer, 0, true);
clone->getOptions()->setScript("ssi_clone");
ITransformable *cursor_clone_t = frame->AddTransformer(cursor_t, clone, "0.1s");
SignalPainter *plot = 0;
plot = ssi_create_id(SignalPainter, 0, "plot");
plot->getOptions()->setTitle("BUTTON (RAW)");
plot->getOptions()->size = 5;
frame->AddConsumer(button_t, plot, "0.1s");
plot = ssi_create_id(SignalPainter, 0, "plot");
plot->getOptions()->setTitle("CURSOR (RAW)");
plot->getOptions()->size = 5;
frame->AddConsumer(cursor_t, plot, "0.1s");
plot = ssi_create_id(SignalPainter, 0, "plot");
plot->getOptions()->setTitle("BUTTON (CLONE)");
plot->getOptions()->size = 5;
frame->AddConsumer(button_clone_t, plot, "0.1s");
plot = ssi_create_id(SignalPainter, 0, "plot");
plot->getOptions()->setTitle("CURSOR (CLONE)");
plot->getOptions()->size = 5;
frame->AddConsumer(cursor_clone_t, plot, "0.1s");
decorator->add("console", 0, 0, 650, 800);
decorator->add("plot*", 650, 0, 400, 400);
decorator->add("monitor*", 650, 400, 400, 400);
frame->Start();
frame->Wait();
frame->Stop();
frame->Clear();
return true;
}
void showMenu(BYTE code, BOOL4 value) {
if (value) {
stateMenu = stateMenu ? 0 : 1;
if(stateMenu) {
mouseInput.showMouse();
} else {
mouseInput.hideMouse();
}
}
}
/**
* Update the mouse capabilities.
* This is called when the mouse capabilities change. The new capabilities
* are given and the connector should update its internal state.
*
* @param pInterface Pointer to this interface.
* @param newCapabilities New capabilities.
* @thread The emulation thread.
*/
DECLCALLBACK(void) vmmdevUpdateMouseCapabilities(PPDMIVMMDEVCONNECTOR pInterface, uint32_t fNewCaps)
{
PDRVMAINVMMDEV pDrv = PDMIVMMDEVCONNECTOR_2_MAINVMMDEV(pInterface);
Console *pConsole = pDrv->pVMMDev->getParent();
/*
* Tell the console interface about the event
* so that it can notify its consumers.
*/
Mouse *pMouse = pConsole->getMouse();
if (pMouse) /** @todo and if not? Can that actually happen? */
pMouse->onVMMDevGuestCapsChange(fNewCaps & VMMDEV_MOUSE_GUEST_MASK);
}
bool ex_stream_info(void *arg) {
Factory::RegisterDLL("ssimouse");
ITheFramework *frame = Factory::GetFramework();
Decorator *decorator = ssi_create (Decorator, 0, true);
frame->AddDecorator(decorator);
ITheEventBoard *board = Factory::GetEventBoard();
//ClockEventSender *eclock = ssi_create(ClockEventSender, 0, true);
Mouse *mouse = ssi_create(Mouse, "mouse", true);
mouse->getOptions()->mask = Mouse::LEFT;
mouse->getOptions()->scale = true;
mouse->getOptions()->single = false;
mouse->getOptions()->sendEvent = true;
ITransformable *cursor_p = frame->AddProvider(mouse, SSI_MOUSE_CURSOR_PROVIDER_NAME);
ITransformable *button_p = frame->AddProvider(mouse, SSI_MOUSE_BUTTON_PROVIDER_NAME);
frame->AddSensor(mouse);
board->RegisterSender(*mouse);
Websocket *websocket = ssi_create(Websocket, 0, true);
websocket->getOptions()->setHttpRoot("stream_to_browser_info");
websocket->getOptions()->send_info = true;
//frame->AddConsumer(cursor_p, websocket, "0.25s");
ssi::ITransformable *src[2] = { cursor_p, button_p };
frame->AddConsumer(2, src, websocket, "1");
board->RegisterSender(*websocket);
board->RegisterListener(*websocket);
EventMonitor *monitor = ssi_create_id (EventMonitor, 0, "monitor");
board->RegisterListener(*monitor);
decorator->add("console", 0, 0, 650, 800);
decorator->add("plot*", 650, 0, 400, 400);
decorator->add("monitor*", 650, 400, 400, 400);
board->Start();
frame->Start();
frame->Wait();
frame->Stop();
frame->Clear();
return true;
}
Mouse *Mouse::createInstance()
{
Gpm_Connect conn;
conn.eventMask = ~0;
conn.defaultMask = ~GPM_HARD;
conn.maxMod = ~0;
conn.minMod = 0;
s32 fd = open_gpm(&conn);
if (fd == -1) return 0;
Mouse *mouse = new Mouse();
mouse->setFd(fd);
return mouse;
}
bool Application::OnUpdate()
{
//System Update
m_pMouse->Update();
m_pKeyboard->Update();
m_pCamera->Update();
m_pGameTime->Update();
//m_fRot += PI * GameTime::GetTimeElapsed();
//m_pScene->SetRotateY(m_fRot);
m_pScene->Update();
if(m_pKeyboard->IsKeyPressed(KEY_1))
{
m_pParent->DetachChild(m_pChild);
}
else if(m_pKeyboard->IsKeyPressed(KEY_2))
{
m_pParent->AttachChild(m_pChild);
}
m_pChild->Update();
DX11Camera::FreeLookCamera(m_pCamera,10.0f);
//m_pCamera->LookAt(D3DXVECTOR3(0,0,0));
//Window Update
return m_pWindow->Tick();
}
virtual void onMouseDown(const ViewpointWindow& w, const Mouse& m){
switch(m.button()){
// case Mouse::LEFT: printf("Pressed left mouse button.\n"); break;
// case Mouse::RIGHT: printf("Pressed right mouse button.\n"); break;
// case Mouse::MIDDLE: printf("Pressed middle mouse button.\n"); break;
}
}
bool ex_event(void *args)
{
ITheFramework *frame = Factory::GetFramework();
ITheEventBoard *board = Factory::GetEventBoard();
Decorator *decorator = ssi_create(Decorator, 0, true);
frame->AddDecorator(decorator);
Mouse *mouse = ssi_create(Mouse, 0, true);
mouse->getOptions()->mask = Mouse::LEFT;
ITransformable *button_t = frame->AddProvider(mouse, SSI_MOUSE_BUTTON_PROVIDER_NAME);
ITransformable *cursor_t = frame->AddProvider(mouse, SSI_MOUSE_CURSOR_PROVIDER_NAME);
frame->AddSensor(mouse);
PythonConsumer *py_send = ssi_create_id(PythonConsumer, 0, "pysend");
py_send->getOptions()->setScript("ssi_send");
ITransformable *input[] = { button_t, cursor_t };
frame->AddConsumer(2, input, py_send, "100ms");
board->RegisterSender(*py_send);
PythonObject *py_listen = ssi_create_id(PythonObject, 0, "pylisten");
py_listen->getOptions()->setScript("ssi_listen");
board->RegisterListener(*py_listen, py_send->getEventAddress());
EventMonitor *monitor = ssi_create_id(EventMonitor, 0, "monitor");
board->RegisterListener(*monitor, 0, 10000u);
SignalPainter *plot = 0;
plot = ssi_create_id(SignalPainter, 0, "plot");
plot->getOptions()->setTitle("CURSOR");
frame->AddEventConsumer(cursor_t, plot, board, py_send->getEventAddress());
decorator->add("console", 0, 0, 650, 800);
decorator->add("plot*", 650, 0, 400, 400);
decorator->add("monitor*", 650, 400, 400, 400);
board->Start();
frame->Start();
frame->Wait();
frame->Stop();
board->Stop();
frame->Clear();
board->Clear();
return true;
}
int main(int argc, char** argv)
{
// Create freeglut window
GlutWindowManager* windowMgr = GlutWindowManager::GetInstance();
//StaticData::SetWindowManager(windowManager);
windowMgr->Init(argc, argv);
Window* window = windowMgr->NewWindow(1, 500, 500, 200, 200, "Window 1");
// Create mesh renderer (init openGL)
MeshRenderer* meshRenderer = new MeshRenderer(WINDOW_WIDTH, WINDOW_HEIGHT);
//StaticData::SetMeshRenderer(meshRenderer);
meshRenderer->Init();
// Load mesh
Mesh* mesh = NULL;
Rendering::Operators::ObjReader::LoadMesh("Models\\cube.obj", mesh, true);
Rendering::Operators::MeshTransformation::Triangulate(mesh);
mesh->ComputeNormals();
mesh->color = glm::vec4(0.0f, 1.0f, 0.0f, 1.0f);
meshRenderer->SetMesh(mesh);
meshRenderer->SetRenderMode((RenderMode)(RenderMode::VERTICES | RenderMode::WIREFRAME));
meshRenderer->SetLightType(LightType::POINT_LIGHT);
meshRenderer->SetLightColor(glm::vec4(1.0f, 1.0f, 1.0f, 1.0f));
//Operators::MeshTransformation::Inflate(mesh, 0.1f);
//meshRenderer->UpdateMeshConnectivity();
// Create a WindowRenderer and link it to the window
WindowRenderer winRenderer(meshRenderer);
window->Attach(&winRenderer);
// Create manipulators
MouseManipulator mouseManip(meshRenderer);
Mouse* mouse = windowMgr->GetMouse();
mouse->Attach(&mouseManip);
// Start main loop
windowMgr->Display();
//delete windowManager;
delete meshRenderer;
return 0;
}
bool CallHandlers(Event& e)
{
fnhandler *h = handlers;
mouse.hide();
while(h)
{
if(h->handle_event(e))
{
mouse.show();
return true;
}
h = h->next;
}
mouse.show();
return false;
}
Cursor::Cursor (void) {
sizex=sizey=4;
m.Read ();
x=lx=m.x;
y=ly=m.y;
visible=0;
buffer=new byte[sizex*sizey];
}
//! [0]
int main(int argc, char **argv)
{
QApplication app(argc, argv);
qsrand(QTime(0,0,0).secsTo(QTime::currentTime()));
//! [0]
//! [1]
QGraphicsScene scene;
scene.setSceneRect(-300, -300, 600, 600);
//! [1] //! [2]
scene.setItemIndexMethod(QGraphicsScene::NoIndex);
//! [2]
//! [3]
for (int i = 0; i < MouseCount; ++i) {
Mouse *mouse = new Mouse;
mouse->setPos(::sin((i * 6.28) / MouseCount) * 200,
::cos((i * 6.28) / MouseCount) * 200);
scene.addItem(mouse);
}
//! [3]
//! [4]
QGraphicsView view(&scene);
view.setRenderHint(QPainter::Antialiasing);
view.setBackgroundBrush(QPixmap(":/images/cheese.jpg"));
//! [4] //! [5]
view.setCacheMode(QGraphicsView::CacheBackground);
view.setViewportUpdateMode(QGraphicsView::BoundingRectViewportUpdate);
view.setDragMode(QGraphicsView::ScrollHandDrag);
//! [5] //! [6]
view.setWindowTitle(QT_TRANSLATE_NOOP(QGraphicsView, "Colliding Mice"));
#if defined(Q_WS_S60) || defined(Q_WS_MAEMO_5) || defined(Q_WS_SIMULATOR)
view.showMaximized();
#else
view.resize(400, 300);
view.show();
#endif
QTimer timer;
QObject::connect(&timer, SIGNAL(timeout()), &scene, SLOT(advance()));
timer.start(1000 / 33);
return app.exec();
}
void BasicButton::update() {
Mouse* mouse = Locator::mouse;
// if the mouse button is pressed and it is on top of the button, update button pressed flag
if(m_activated == false && mouse->getButtonState(0) == true){
int x, y;
x = mouse->getx();
y = mouse->gety();
Rectangle buttonRect(m_position.x, m_position.y, m_width, m_height);
Relation relation = MBRRelate(x, y, buttonRect);
if(relation == INSIDE){
m_selected = true;
}
}
// if mouse button is depressed and mouse is outside of the button, unset the flag
if(m_activated == true && mouse->getButtonState(0) == false){
int x, y;
x = mouse->getx();
y = mouse->gety();
Rectangle buttonRect(m_position.x, m_position.y, m_width, m_height);
Relation relation = MBRRelate(x, y, buttonRect);
if(relation == INSIDE || relation == TOUCH){
// perform some action
// how? register callback function?
// set a flag and something can poll for it?
}
else{
m_selected = false;
}
}
}
void handleMouseclick(int button, int state, int x, int y)
{
if (state == GLUT_DOWN)
{
if (button == GLUT_LEFT_BUTTON)
{
float x1 = x;
float y1 = y;
float x2 = coins[9].x;
float y2 = coins[9].y;
Mouse strikernew;
strikernew.windowCood(coins[9].x,coins[9].y);
x2 = strikernew.a;
y2 = strikernew.b;
d = sqrt(pow((x1-x2),2) + pow((y1-y2),2));
float theta = atan2f(y1-y2,x1-x2);
strike_angle = theta * 180 / PI;
}
//else if (button == GLUT_RIGHT_BUTTON)
//theta -= 15;
}
if (state == GLUT_UP)
{
if (button == GLUT_LEFT_BUTTON)
{
float scale = findscale();
strike_angle = strike_angle + 90;
//striker.line.setLength(scale, striker.strike.d);
//printf("%f %f\n", scale,striker.strike.d);
//striker.startMove();
strike = 1;
coins[9].v = coins[9].v + (scale)*(0.005)/d;
coins[9].velx = coins[9].v * sin(DEG2RAD(strike_angle));
coins[9].vely = coins[9].v * cos(DEG2RAD( strike_angle));
}
}
}
/*
* GLUT calls this routine to display the scene
*/
void display() {
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
glLoadIdentity();
// Set up View
view.setView();
// Draw scene
scene.draw();
// Draw on screen plane - Must be drawn last
overlay.draw();
// Write debugging parameters -- (0,0) is lower left corner.
glColor3f(0,0,0);
glWindowPos2i(5,10);
Print("x: %d y:%d mode:%d " , mouse.getx(), mouse.gety(), mouse.getMode());
// Render the scene and make it visible
glFlush();
glutSwapBuffers();
}
void IElement::MouseOver(Mouse mouse)
{
m_hovered = false;
vec2<int> mouse_pos = mouse.GetMousePosition();
if (mouse_pos.x >= m_box.x && mouse_pos.x <= (m_box.x + m_box.width)
&& mouse_pos.y >= m_box.y && mouse_pos.y <= (m_box.y + m_box.height))
{
if (m_border_radius == 0)
{
m_hovered = true;
}
//test for the 4 rounded corners
else
{
vec2<int> upperLeft = vec2<int>(m_box.x + m_border_radius, m_box.y + m_border_radius);
vec2<int> upperRight = vec2<int>(m_box.x + m_box.width - m_border_radius, m_box.y + m_border_radius);
vec2<int> lowerLeft = vec2<int>(m_box.x + m_border_radius, m_box.y + m_box.height - m_border_radius);
vec2<int> lowerRight = vec2<int>(m_box.x + m_box.width - m_border_radius, m_box.y + m_box.height - m_border_radius);
if (mouse_pos.x < upperLeft.x && mouse_pos.y < upperLeft.y)
{
if (mouse_pos.distance(upperLeft) <= m_border_radius)
{
m_hovered = true;
}
}
else if (mouse_pos.x > upperRight.x && mouse_pos.y < upperRight.y)
{
if (mouse_pos.distance(upperRight) <= m_border_radius)
{
m_hovered = true;
}
}
else if (mouse_pos.x < lowerLeft.x && mouse_pos.y > lowerLeft.y)
{
if (mouse_pos.distance(lowerLeft) <= m_border_radius)
{
m_hovered = true;
}
}
else if (mouse_pos.x > lowerRight.x && mouse_pos.y > lowerRight.y)
{
if (mouse_pos.distance(lowerRight) <= m_border_radius)
{
m_hovered = true;
}
}
else
{
m_hovered = true;
}
}
}
}
void pushMouseObject(lua_State* L, Mouse& mouse)
{
int screenRef = luaL_ref(L, LUA_REGISTRYINDEX);
auto wrap = script::push(L, &mouse, screenRef);
lua_pushvalue(L, -1);
int mouseRef = luaL_ref(L, LUA_REGISTRYINDEX);
script::push(L, &mouse.left(), mouseRef);
wrap->setAttribute(L, LeftAttribute);
lua_pop(L, 1);
script::push(L, &mouse.middle(), mouseRef);
wrap->setAttribute(L, MiddleAttribute);
lua_pop(L, 1);
script::push(L, &mouse.right(), mouseRef);
wrap->setAttribute(L, RightAttribute);
lua_pop(L, 1);
}
void
process_mouse_motion(const SDL_MouseMotionEvent& evt)
{
mouse.change_point(Point(evt.x,evt.y));
if(evt.state&SDL_BUTTON_LMASK){mouse.left.press();}
else {mouse.left.unpress();}
if(evt.state&SDL_BUTTON_RMASK){mouse.right.press();}
else {mouse.right.unpress();}
}
bool ex_sensor (void *arg) {
ITheFramework *frame = Factory::GetFramework ();
//IThePainter *painter = Factory::GetPainter ();
//ITheEventBoard *board = Factory::GetEventBoard ();
Mouse *mouse = ssi_pcast (Mouse, Factory::Create (Mouse::GetCreateName (), "mouse"));
mouse->getOptions ()->mask = Mouse::LEFT;
ITransformable *cursor_p = frame->AddProvider (mouse, SSI_MOUSE_CURSOR_PROVIDER_NAME);
ITransformable *button_p = frame->AddProvider (mouse, SSI_MOUSE_BUTTON_PROVIDER_NAME);
frame->AddSensor (mouse);
ZeroEventSender *ezero = ssi_create (ZeroEventSender, "ezero", true);
ezero->getOptions ()->mindur = 0.2;
frame->AddConsumer (cursor_p, ezero, "0.25s");
/*
board->RegisterSender (*ezero);
SignalPainter *sigpaint = ssi_create (SignalPainter, 0, true);
sigpaint->getOptions ()->setName ("mouse");
sigpaint->getOptions ()->size = 2.0;
frame->AddConsumer (cursor_p, sigpaint, "0.2s");
sigpaint= ssi_create (SignalPainter, 0, true);
sigpaint->getOptions ()->setName ("mouse (tr)");
frame->AddEventConsumer (cursor_p, sigpaint, board, ezero->getEventAddress ());
*/
frame->Start ();
//board->Start ();
//painter->Arrange (2, 1, 0, 0, 800, 400);
frame->Wait ();
//board->Stop ();
frame->Stop ();
frame->Clear ();
//board->Clear ();
//painter->Clear ();
return true;
}
bool ex_trigger (void *arg) {
ITheFramework *frame = Factory::GetFramework ();
//ssi_pcast(TheFramework, frame)->getOptions()->setConsolePos(800, 200, 400, 200);
Mouse *mouse = ssi_create (Mouse, 0, false);
mouse->getOptions ()->mask = Mouse::LEFT;
ITransformable *cursor_p = frame->AddProvider (mouse, SSI_MOUSE_CURSOR_PROVIDER_NAME);
ITransformable *button_p = frame->AddProvider (mouse, SSI_MOUSE_BUTTON_PROVIDER_NAME);
frame->AddSensor (mouse);
FileWriter *writer = ssi_create (FileWriter, 0, true);
writer->getOptions ()->type = File::ASCII;
frame->AddConsumer (cursor_p, writer, "0.2s", 0, 0, button_p);
frame->Start ();
frame->Wait ();
frame->Stop ();
frame->Clear ();
return true;
}
bool done()
{
while( SDL_PollEvent(&event))
{
if( event.type == SDL_QUIT) return true;
if( event.type == SDL_KEYDOWN )
{
if(event.key.keysym.scancode == SDL_SCANCODE_ESCAPE) return true;
}
mouse.Update();
}
return false;
}
