const GuiEvent MenuButton::handleInput(const sf::Event& event)
{
if(!this->visible)
{
return GuiEvent::noEvent;
}
for(Component* lpComponent: this->lp_children)
{
GuiEvent guiEvent = lpComponent->handleInput(event);
if(guiEvent.type != GuiEvent::None)
{
return guiEvent;
}
}
if(event.type == sf::Event::MouseButtonPressed)
{
sf::Vector2f mousePos(event.mouseButton.x, event.mouseButton.y);
if(Utils::length(mousePos - this->getAbsPosition()) <= this->radius)
{
//sf::Sound sound;
//sound.setBuffer(assetsInstance.sounds.select);
//sound.play();
assetsInstance.sounds.select.play();
GuiEvent guiEvent;
guiEvent.type = GuiEvent::ButtonEvent;
guiEvent.click.id = this->mId;
guiEvent.click.mouseButton = event.mouseButton.button;
return guiEvent;
}
else
{
return GuiEvent::noEvent;
}
}
else if(event.type == sf::Event::MouseMoved)
{
sf::Vector2f mousePos(event.mouseMove.x, event.mouseMove.y);
if(Utils::length(mousePos - this->getAbsPosition()) <= this->radius)
{
if(this->state != OVER) assetsInstance.sounds.over.play();
this->state = OVER;
}
else
{
this->state = NORMAL;
}
return GuiEvent::noEvent;
}
return GuiEvent::noEvent;
}
PlayerState* PlayerAttackState::handleEvent(const sf::Event& event,
const sf::RenderWindow& renderWindow)
{
MeleeRectComponent* meleeRectComp = mPlayer->comp<MeleeRectComponent>();
if (meleeRectComp->meleeRectIsDelaying() ||
mIsAttackCommandQueue)
return nullptr;
/*if (event.key.code == sf::Keyboard::Up)
mIsAttackCommandQueue = true;*/
SpiritCoreComponent* spiritCoreComp = mPlayer->nonCreateComp<SpiritCoreComponent>();
if (event.type == sf::Event::MouseButtonPressed &&
event.mouseButton.button == sf::Mouse::Left
&& (!spiritCoreComp || (!spiritCoreComp->isRestoring() &&
!spiritCoreComp->noSpiritCoreLeft())))
{
mIsAttackCommandQueue = true;
sf::Vector2f mousePos(renderWindow.mapPixelToCoords(sf::Mouse::getPosition(renderWindow)));
sf::Vector2f entityWorldPos = mPlayer->comp<TransformableComponent>()->getWorldPosition(true);
mLatestAttackDir = Utility::unitVector(mousePos - entityWorldPos);
return nullptr;
}
if (event.type == sf::Event::MouseButtonPressed &&
event.mouseButton.button == sf::Mouse::Right &&
(!spiritCoreComp || (!spiritCoreComp->isRestoring() &&
!spiritCoreComp->noSpiritCoreLeft())))
{
sf::Vector2f mousePos(renderWindow.mapPixelToCoords(sf::Mouse::getPosition(renderWindow)));
sf::Vector2f entityWorldPos = mPlayer->comp<TransformableComponent>()->getWorldPosition(true);
return new PlayerFireBallState(mPlayer, mPlayerStateTable);
//return new PlayerAimRangeState(mPlayer, mPlayerStateTable);
}
/*if (event.type == sf::Event::MouseButtonPressed &&
event.mouseButton.button == sf::Mouse::Right)
{
sf::Vector2f mousePos(renderWindow.mapPixelToCoords(sf::Mouse::getPosition(renderWindow)));
sf::Vector2f entityWorldPos = mPlayer->comp<TransformableComponent>()->getWorldPosition(true);
return new PlayerSpiritState(mPlayer, Utility::unitVector(mousePos - entityWorldPos), mPlayerStateTable);
}*/
return nullptr;
}
Angle Client::calcPlayerObjAngle(Vec2<int> mouseScreenPos)
{
if (worldModel.getPlayerObjs().exists(playerId))
{
PlayerObj *playerObj = (worldModel.getPlayerObjs())[playerId];
float angle;
Pos mousePos(viewportHandler.screenToGame(worldRenderer.getRenderArea(playerObj), mouseScreenPos));
Vec aimVec = mousePos - playerObj->pos;
aimVec.normalize();
if ((aimVec.x > 0.5) || (aimVec.x < 0.5f))
{
angle = asin(aimVec.y);
if (aimVec.x < 0.0f) angle = PI_F - angle;
}
else
{
angle = acos(aimVec.x);
if (aimVec.y < 0.0f) angle = -angle;
}
return angle;
}
return 0.0f;
}
void JavascriptInvocation::leftClick(int x, int y) {
QPoint mousePos(x, y);
JavascriptInvocation::mouseEvent(QEvent::MouseMove, mousePos, Qt::NoButton);
JavascriptInvocation::mouseEvent(QEvent::MouseButtonPress, mousePos, Qt::LeftButton);
JavascriptInvocation::mouseEvent(QEvent::MouseButtonRelease, mousePos, Qt::LeftButton);
}
void Player::draw(sf::RenderWindow &render) const
{
View view(sf::FloatRect(0, 0, m_drawDim.x*(m_zooms[m_controller.getZoom()]), m_drawDim.y*m_zooms[m_controller.getZoom()]));
view.setCenter(m_controller.getViewCenter());
view.setViewport(sf::FloatRect(m_drawPos.x/m_resolution.x, m_drawPos.y/m_resolution.y, m_drawDim.x/m_resolution.x, m_drawDim.y/m_resolution.y));
render.setView(view);
std::vector<Entity*> toDraw = m_world.getEntitiesInRect(screenToWorld(Vec(0, 0)), screenToWorld(m_drawDim));
//m_world.draw(render);
for(int i=0; i<toDraw.size(); i++)
{
toDraw[i]->draw(render);
}
for(int i=0; i<m_selection.size(); i++)
{
m_selection[i]->drawSelected(render);
}
draw::drawRect(render, Vec(0, 0), Vec(m_world.getDim()), sf::Color::White);
for(int i=0; i<toDraw.size(); i++)
{
toDraw[i]->drawForeground(render, screenToWorld(mousePos()));
}
view.reset(sf::FloatRect(0, 0, m_drawDim.x, m_drawDim.y));
render.setView(view);
if(m_selecting)
{
draw::drawRect(render, worldToScreen(m_A), worldToScreen(m_B)-worldToScreen(m_A), sf::Color(50, 100, 255, 100), 3);
draw::drawRect(render, worldToScreen(m_A), worldToScreen(m_B)-worldToScreen(m_A), sf::Color(50, 100, 255, 100));
}
m_gui->drawChildren(render, Vec(0, 0), m_drawDim);
Displayer::instance.draw(render);
draw::drawRect(render, Vec(1, 1), m_drawDim-Vec(1, 1)*2, sf::Color::White);
}
void mouseup(char btn) {
CGEventType eventType;
CGMouseButton button;
switch (btn) {
case 'l':
eventType = kCGEventLeftMouseDown;
button = kCGMouseButtonLeft;
break;
case 'r':
eventType = kCGEventRightMouseDown;
button = kCGMouseButtonRight;
break;
case 'm':
eventType = kCGEventOtherMouseDown;
button = kCGMouseButtonCenter;
break;
default:
eventType = kCGEventNull;
break;
}
if (eventType != kCGEventNull) {
CGEventRef event = CGEventCreateMouseEvent(NULL, eventType, mousePos(), button);
CGEventPost(kCGHIDEventTap, event);
CFRelease(event);
}
}
/**
** Called if the mouse is moved
**
** @param callbacks Callback structure for events.
** @param ticks Denotes time-stamp of video-system
** @param x X movement
** @param y Y movement
*/
void InputMouseMove(const EventCallback &callbacks,
unsigned ticks, int x, int y)
{
PixelPos mousePos(x, y);
// Don't reset the mouse state unless we really moved
#ifdef USE_TOUCHSCREEN
const int buff = 32;
const PixelDiff diff = LastMousePos - mousePos;
if (abs(diff.x) > buff || abs(diff.y) > buff) {
MouseState = InitialMouseState;
LastMouseTicks = ticks;
// Reset rectangle select cursor state if we moved by a lot
// - rectangle select should be a drag, not a tap
if (CursorState == CursorStateRectangle
&& (abs(diff.x) > 2 * buff || abs(diff.y) > 2 * buff)) {
CursorState = CursorStatePoint;
}
}
LastMousePos = mousePos;
#else
if (LastMousePos != mousePos) {
MouseState = InitialMouseState;
LastMouseTicks = ticks;
LastMousePos = mousePos;
}
#endif
callbacks.MouseMoved(mousePos);
}
void Player::sendOrder()
{
if(m_selection.size() > 0)
{
if(m_selection[0]->getType() == BALL)
{
if(m_controller.pressed(ORDER))
{
std::vector<Ball*> balls;
for(int i=0; i<m_selection.size(); i++)
{
Ball* ball = (Ball*)m_selection[i];
balls.push_back(ball);
m_world.stopMovement(ball);
}
MovementHandler *handler = new MovementHandler(balls, m_controller);
m_world.addMovement(handler);
}
else if(m_controller.down(ORDER))
{
m_world.updateTarget((Ball*)m_selection[0], screenToWorld(mousePos()));
}
}
else if(m_selection[0]->getType() == BUILDING)
{
Building* building = (Building*)m_selection[0];
building->receiveOrder(m_controller);
}
}
}
void PlayState::processEvents(sf::Event event)
{
switch (event.type)
{
case sf::Event::KeyPressed:
handlePlayerInput(event.key.code, true);
break;
case sf::Event::KeyReleased:
handlePlayerInput(event.key.code, false);
break;
}
sf::Vector2i mousePos(event.mouseButton.x, event.mouseButton.y);
if (exitButton.getGlobalBounds().contains((float)mousePos.x, (float)mousePos.y))
{
GameStateManager::Instance()->clean();
}
else if (menuButton.getGlobalBounds().contains((float)mousePos.x, (float)mousePos.y))
{
GameStateManager::Instance()->changeGameState(new MainMenuState);
}
/*if ((mousePos.x > menuButton.getPosition().x - menuButton.getLocalBounds().width / 2) &&
(mousePos.x < menuButton.getPosition().x + menuButton.getLocalBounds().width / 2) &&
(mousePos.y > menuButton.getPosition().y - menuButton.getLocalBounds().height / 2) &&
(mousePos.y < menuButton.getPosition().y + menuButton.getLocalBounds().height / 2))
{
}*/
}
void FlowField::addCircularForce(float x, float y, float radius, float strength) {
float pctX = x / fieldWidth;
float pctY = y / fieldWidth;
int cols = fieldWidth / resolution;
int rows = fieldHeight / resolution;
int xVal = pctX * cols;
int yVal = pctY * rows;
ofVec2f mousePos(x, y);
for( int y=0; y<flowList.size(); y++){
for( int x=0; x<flowList[y].size(); x++){
ofVec2f np( x*resolution, y*resolution );
if( np.distance(mousePos) < radius ){
float pct = 1 - (np.distance(mousePos) / radius);
// add strength towards the mouse
ofVec2f dir = (np - mousePos);
flowList[y][x].x -= dir.normalized().y * strength;
flowList[y][x].y += dir.normalized().x * strength;
}
}
}
}
Ray Camera::ScreenPointToRay(vec3 _position) {
float nxPos = _position.x / Window::width;
float nyPos = _position.y / Window::height;
float sxPos = nxPos - 0.5f;
float syPos = nyPos - 0.5f;
float fxPos = sxPos;
float fyPos = syPos;
if (!orthographic) {
fxPos *= 2;
fyPos *= -2;
} else {
fxPos *= orthographicSize / 2;
fyPos *= -orthographicSize / 2;
}
mat4 invViewProj = glm::inverse(projectionMatrix * viewMatrix);
vec4 mousePos(fxPos, fyPos, -1, 1);
vec4 worldScreenPoint = invViewProj * mousePos;
worldScreenPoint /= worldScreenPoint.w;
vec3 rayOrigin;
vec3 dir;
rayOrigin = transform->worldMatrix[3].xyz();
if (!orthographic) {
rayOrigin = transform->worldMatrix[3].xyz();
}
dir = rayOrigin - worldScreenPoint.xyz;
return Ray(rayOrigin, dir);
}
bool TicTacToe::handleEvent(const sf::Event& event, const sf::Window& relativeTo)
{
if(event.type == sf::Event::MouseMoved)
m_lastPointerLoc = sf::Vector2f(sf::Mouse::getPosition(relativeTo).x, sf::Mouse::getPosition(relativeTo).y);
if(m_multi || (!m_multi && m_turn != m_iaColor))
{
if(event.type == sf::Event::MouseButtonReleased && event.mouseButton.button == sf::Mouse::Left )
{
sf::Vector2f mousePos(sf::Mouse::getPosition(relativeTo).x, sf::Mouse::getPosition(relativeTo).y);
if(mousePos.x > OFFSET_X && mousePos.x < OFFSET_X + GRID_SIZE*CASE_SIZE
&& mousePos.y > OFFSET_Y && mousePos.y < OFFSET_Y + GRID_SIZE*CASE_SIZE)
{
int caseX = (mousePos.x - OFFSET_X) / CASE_SIZE;
int caseY = (mousePos.y - OFFSET_Y) / CASE_SIZE;
if(m_grid[caseY][caseX] == NONE)
{
m_grid[caseY][caseX] = m_turn;
switchTurn();
}
}
}
}
return false;
}
bool Inventory::HandleEvent(sf::Event& e)
{
bool Modification = false;
if (e.type == sf::Event::KeyPressed)
{
if ((e.key.code == sf::Keyboard::B && sf::Keyboard::isKeyPressed(sf::Keyboard::LShift)) ||
(e.key.code == sf::Keyboard::LShift && sf::Keyboard::isKeyPressed(sf::Keyboard::B)))
{
m_IsAllOpen = !m_IsAllOpen;
Modification = true;
}
}
if (e.type == sf::Event::MouseButtonPressed)
{
sf::Vector2i mousePos(e.mouseButton.x, e.mouseButton.y);
for (int iBag = 0 ; iBag < 4 ; ++iBag)
{
// TODO: Check if function is correct
if (m_Bags[iBag]->IsInArea(mousePos))
{
m_IsBagOpen[iBag] = true;
Modification = true;
break;
}
}
}
return Modification;
}
void DDADisplay::mouseMoveEvent(QMouseEvent *event)
{
qDebug() << event->pos();
int y = 400 - event->pos().y();
int x = event->pos().x() - 600;
emit mousePos(QPoint(x, y));
}
void FlowField::addRepelForce(float x, float y, float radius, float strength) {
float pctX = x / fieldWidth;
float pctY = y / fieldWidth;
int cols = fieldWidth / resolution;
int rows = fieldHeight / resolution;
int xVal = pctX * cols;
int yVal = pctY * rows;
ofVec2f mousePos(x, y);
for( int y=0; y<flowList.size(); y++){
for( int x=0; x<flowList[y].size(); x++){
ofVec2f np( x*resolution, y*resolution );
if( np.distance(mousePos) < radius ){
float pct = 1 - (np.distance(mousePos) / radius);
// add strength in the direction it's already moving in
// flowList[y][x] += flowList[y][x].normalized() * strength;
// add strength away from the mouse
ofVec2f dir = (np - mousePos);
flowList[y][x] += dir.normalized() * strength;
}
}
}
}
void human::startSelect()
{
if (m_select)
stopSelect();
sf::Vector2f pos = mousePos(m_rw);
m_select = new sf::Shape();
*m_select = sf::Shape::Rectangle(pos.x+0, pos.y+0, pos.x+1, pos.y+1, sf::Color(255, 0, 0, 50), 2.0f, sf::Color::Green);
}
bool CAppMenu::OnEvent(const sf::Event &event)
{
bool handled = false;
switch (event.type)
{
case sf::Event::MouseButtonPressed:
{
const auto &data = event.mouseButton;
sf::Vector2f mousePos(float(data.x), float(data.y));
m_mousePressCaptured = m_frame.contains(mousePos)
|| (m_isOpen && GetPopupFrame().contains(mousePos));
break;
}
case sf::Event::MouseButtonReleased:
{
const auto &data = event.mouseButton;
sf::Vector2f mousePos(float(data.x), float(data.y));
if (m_mousePressCaptured)
{
if (m_frame.contains(mousePos))
{
OnMenuClicked();
handled = true;
}
else if (m_isOpen)
{
sf::FloatRect popupFrame = GetPopupFrame();
if (popupFrame.contains(mousePos))
{
OnPopupClicked(mousePos.x - popupFrame.left, mousePos.y - popupFrame.top);
handled = true;
}
else
{
m_isOpen = false;
}
}
}
m_mousePressCaptured = false;
break;
}
default:
break;
}
return handled;
}
//--------------------------------------------------------------
void ofApp::mousePressed(int x, int y, int button){
ofVec2f mousePos(x-center.x, y-center.y);
if (mousePos.length()<radius ) {
angle = -mousePos.angleRad(ofVec2f(radius,0));
if (angle<0) {
angle+=TWO_PI;
}
}
}
void CameraController::adjustYawPitch(int mouseX, int mouseY)
{
glm::ivec2 windowCenter = m_window->getSize() / 2;
glm::ivec2 mousePos(mouseX, mouseY);
m_pitch += (mousePos.y - windowCenter.y) * m_lookSpeed;
m_pitch = std::max(-90.f, std::min(m_pitch, 90.f));
m_yaw += (windowCenter.x - mousePos.x) * m_lookSpeed;
}
void EventSenderProxy::mouseMoveTo(double x, double y)
{
m_position.x = x;
m_position.y = y;
QPoint mousePos(m_position.x, m_position.y);
QMouseEvent* event = new QMouseEvent(QEvent::MouseMove,
mousePos, mousePos, Qt::NoButton, m_mouseButtons, Qt::NoModifier);
sendOrQueueEvent(event);
}
void EventSenderProxy::mouseUp(unsigned button, WKEventModifiers)
{
Qt::MouseButton mouseButton = getMouseButton(button);
m_mouseButtons &= ~mouseButton;
QPoint mousePos(m_position.x, m_position.y);
QMouseEvent* event = new QMouseEvent(QEvent::MouseButtonRelease,
mousePos, mousePos, mouseButton, m_mouseButtons, Qt::NoModifier);
sendOrQueueEvent(event);
}
void JavascriptInvocation::rightClick(int x, int y) {
QPoint mousePos(x, y);
m_page->mouseEvent(QEvent::MouseButtonPress, mousePos, Qt::RightButton);
// swallowContextMenuEvent tries to fire contextmenu event in html page
QContextMenuEvent *event = new QContextMenuEvent(QContextMenuEvent::Mouse, mousePos);
m_page->swallowContextMenuEvent(event);
m_page->mouseEvent(QEvent::MouseButtonRelease, mousePos, Qt::RightButton);
}
//--------------------------------------------------------------
void ofApp::update(){
if (leftMouseButtonPressed) {
ofVec2f mousePos(ofGetMouseX(), ofGetMouseY());
if (lastPoint.distance(mousePos) >= minDistance) {
// a.distance(b) calculates the Euclidean distance between point a and b. It's
// the length of the straight line distance between the points.
currentPolyline.curveTo(mousePos); // Here we are using an ofVec2f with curveTo(...)
lastPoint = mousePos;
}
}
}
void SDLMouse::update()
{
SDL_Event event;
SDL_PumpEvents();
while ( SDL_PeepEvents(&event, 1, SDL_GETEVENT, ( SDL_EVENTMASK(SDL_MOUSEBUTTONDOWN) | SDL_EVENTMASK(SDL_MOUSEBUTTONUP) | SDL_EVENTMASK(SDL_MOUSEMOTION) ) ) > 0 )
{
if ( event.type == SDL_MOUSEBUTTONDOWN ) {
cout << endl << " [EE] Mouse Pressed";
if ( gui() != NULL ) {
cout << " gui";
gui()->mousePressed( event.button.x, event.button.y, translateMouseButtons( event.button.button ) );
}
cout << endl;
onMousePressed( event.button.x, event.button.y, translateMouseButtons( event.button.button ) );
} else if ( event.type == SDL_MOUSEBUTTONUP ) {
cout << " [EE] Mouse Released" << endl << endl;
if ( gui() != NULL ) {
cout << " gui";
gui()->mouseReleased( event.button.x, event.button.y, translateMouseButtons( event.button.button ) );
}
cout << endl;
onMouseReleased( event.button.x, event.button.y, translateMouseButtons( event.button.button ) );
} else if ( event.type == SDL_MOUSEMOTION ) {
if ( gui() != NULL )
gui()->mouseMove( event.button.x, event.button.y, translateMouseButtons( event.button.button ) );
onMouseMove( event.button.x, event.button.y, translateMouseButtons( event.button.button ) );
}
}
if ( gui() != NULL ) {
Widget* w = gui()->lastMouseOverWidget();
if ( w != NULL ) {
int x, y;
mousePos( x, y );
MouseCursor* mc = w->getCursor( x - w->absoluteXPos(), y - w->absoluteYPos() );
if ( mc != (MouseCursor*)pCursor ) {
setCursor( mc );
}
}
/* if ( gui()->lastMouseOverWidget() != pLastMouseOver ) {
pLastMouseOver = gui()->lastMouseOverWidget();
if ( pLastMouseOver != NULL ) {
if ( (MouseCursor*)pCursor != pLastMouseOver->cursor() )
setCursor( pLastMouseOver->cursor() );
}
}*/
}
}
Window::Window(QWidget *parent)
: QMainWindow(parent)
{
setWindowTitle("Bresenham's Circle Algo in Qt");
QWidget* centralWidget = new QWidget(this);
drawButton = new QPushButton("Draw", centralWidget);
// drawStepByStepButton = new QPushButton("Step In", centralWidget);
connect(drawButton, SIGNAL(clicked()),
this, SLOT(draw()));
redraw = new QCheckBox("Redraw Display", centralWidget);
redraw->setTristate(false);
redraw->setCheckState(Qt::Checked);
connect(redraw, SIGNAL(stateChanged(int)),
this, SLOT(redrawToggle(int)));
progressBar = new QProgressBar(this);
progressBar->setValue(0);
statusBar = new QStatusBar(centralWidget);
setStatusBar(statusBar);
infoLabel = new QLabel("Circle Drawing Algorithm, in C++ using Qt. \nAuthor: \nRohit Yadav & Abhishek Kumar \nCSE PartIII, \n2009-2010.", centralWidget);
infoLabel->setWordWrap(true);
display = new DisplayWidget(centralWidget);
connect(display, SIGNAL(updateProgressBar(float)),
this, SLOT(updateProgressBar(float)));
connect(display, SIGNAL(mousePos(QPoint)),
this, SLOT(updateMousePos(QPoint)));
scrollArea = new QScrollArea(this);
scrollArea->setBackgroundRole(QPalette::Dark);
scrollArea->setWidget(display);
QVBoxLayout *vbox = new QVBoxLayout();
vbox->addWidget(scrollArea, 10);
vbox->addWidget(progressBar, 1);
QVBoxLayout *vbox1 = new QVBoxLayout();
vbox1->addWidget(redraw,1);
vbox1->addWidget(drawButton, 1);
vbox1->addWidget(infoLabel, 1);
QHBoxLayout *hbox = new QHBoxLayout(centralWidget);
hbox->addLayout(vbox, 10);
hbox->addLayout(vbox1, 1);
setCentralWidget(centralWidget);
}
// Get the current mouse position
void GraphicsView::mouseMoveEvent(QMouseEvent *e) {
emit mousePos(e->pos().x(),e->pos().y());
// Detect click + dragging
if(buttonpressed)
mousedragged = true;
QGraphicsView::mouseMoveEvent(e);
}
void Canvas::OnEventMouseMoved(const Nz::EventHandler* /*eventHandler*/, const Nz::WindowEvent::MouseMoveEvent& event)
{
std::size_t bestEntry = InvalidCanvasIndex;
float bestEntryArea = std::numeric_limits<float>::infinity();
Nz::Vector3f mousePos(float(event.x), float(event.y), 0.f);
for (std::size_t i = 0; i < m_widgetEntries.size(); ++i)
{
const Nz::Boxf& box = m_widgetEntries[i].box;
if (box.Contains(mousePos))
{
float area = box.width * box.height;
if (area < bestEntryArea)
{
bestEntry = i;
bestEntryArea = area;
}
}
}
if (bestEntry != InvalidCanvasIndex)
{
if (m_hoveredWidget != bestEntry)
{
if (m_hoveredWidget != InvalidCanvasIndex)
{
WidgetEntry& previouslyHovered = m_widgetEntries[m_hoveredWidget];
previouslyHovered.widget->OnMouseExit();
}
m_hoveredWidget = bestEntry;
m_widgetEntries[m_hoveredWidget].widget->OnMouseEnter();
if (m_cursorController)
m_cursorController->UpdateCursor(Nz::Cursor::Get(m_widgetEntries[m_hoveredWidget].cursor));
}
WidgetEntry& hoveredWidget = m_widgetEntries[m_hoveredWidget];
int x = static_cast<int>(std::round(event.x - hoveredWidget.box.x));
int y = static_cast<int>(std::round(event.y - hoveredWidget.box.y));
hoveredWidget.widget->OnMouseMoved(x, y, event.deltaX, event.deltaY);
}
else if (m_hoveredWidget != InvalidCanvasIndex)
{
m_widgetEntries[m_hoveredWidget].widget->OnMouseExit();
m_hoveredWidget = InvalidCanvasIndex;
if (m_cursorController)
m_cursorController->UpdateCursor(Nz::Cursor::Get(Nz::SystemCursor_Default));
}
}
void LevelEditor::HandleEvents(sf::Event &event)
{
if(event.Type == sf::Event::MouseButtonPressed)
{
if(event.MouseButton.Button == sf::Mouse::Left)
{
Vec2D mousePos((Real)event.MouseButton.X, (Real)event.MouseButton.Y);
if(!SetTool(mousePos))
{
Entity *entity = 0;
switch(m_currentTool)
{
case WALL:
entity = new Wall();
break;
case ENEMY_SPAWN_POINT:
entity = new EnemySpawnPoint();
break;
};
if(entity)
{
mousePos += gWorld.m_camera.m_position.Opposite();
int cell = gWorld.GetLevel().GetCellFromPoint(mousePos);
entity->SetPosition(gWorld.GetLevel().SnapToCenter(mousePos));
gWorld.GetLevel().AddEntity(cell, entity);
}
}
}
else if(event.MouseButton.Button == sf::Mouse::Right)
{
Vec2D mousePos((Real)event.MouseButton.X, (Real)event.MouseButton.Y);
mousePos += gWorld.m_camera.m_position.Opposite();
int cell = gWorld.GetLevel().GetCellFromPoint(mousePos);
gWorld.GetLevel().RemoveEntityFromCell(cell);
}
}
}
void QgsMapCanvas::wheelEvent( QWheelEvent *e )
{
// Zoom the map canvas in response to a mouse wheel event. Moving the
// wheel forward (away) from the user zooms in
QgsDebugMsg( "Wheel event delta " + QString::number( e->delta() ) );
if ( mMapTool )
{
mMapTool->wheelEvent( e );
}
if ( QgsApplication::keyboardModifiers() )
{
// leave the wheel for map tools if any modifier pressed
return;
}
switch ( mWheelAction )
{
case WheelZoom:
// zoom without changing extent
if ( e->delta() > 0 )
zoomIn();
else
zoomOut();
break;
case WheelZoomAndRecenter:
// zoom and don't change extent
zoomWithCenter( e->x(), e->y(), e->delta() > 0 );
break;
case WheelZoomToMouseCursor:
{
// zoom map to mouse cursor
double scaleFactor = e->delta() > 0 ? 1 / mWheelZoomFactor : mWheelZoomFactor;
QgsPoint oldCenter = center();
QgsPoint mousePos( getCoordinateTransform()->toMapPoint( e->x(), e->y() ) );
QgsPoint newCenter( mousePos.x() + (( oldCenter.x() - mousePos.x() ) * scaleFactor ),
mousePos.y() + (( oldCenter.y() - mousePos.y() ) * scaleFactor ) );
zoomByFactor( scaleFactor, &newCenter );
break;
}
case WheelNothing:
// well, nothing!
break;
}
}
void DiagramScene::mousePressEvent(QGraphicsSceneMouseEvent *event)
{
QPointF mousePos(event->buttonDownScenePos(Qt::LeftButton).x(),
event->buttonDownScenePos(Qt::LeftButton).y());
movingItem = itemAt(mousePos.x(), mousePos.y());
if (movingItem != 0 && event->button() == Qt::LeftButton) {
oldPos = movingItem->pos();
}
clearSelection();
QGraphicsScene::mousePressEvent(event);
}
