void Qt5GLWidget::mouseMoveEvent(QMouseEvent* event) {
int x = event->x();
int y = m_height - event->y() + 1;
int dx = x - m_x;
int dy = m_y - y;
m_x = x;
m_y = y;
if ((m_leftDown || m_rightDown || m_middleDown)
&& (abs(x - m_startX) > m_mouseTolerance || abs(y - m_startY) > m_mouseTolerance)) {
if (!m_mouseDragged) {
// we are just starting to drag
if (m_leftDown) mouseDragStart(Left, m_startX, m_startY);
if (m_rightDown) mouseDragStart(Right, m_startX, m_startY);
if (m_middleDown) mouseDragStart(Middle, m_startX, m_startY);
}
m_mouseDragged = true;
if (m_leftDown) mouseDrag(Left, dx, dy, x, y);
if (m_rightDown) mouseDrag(Right, dx, dy, x, y);
if (m_middleDown) mouseDrag(Middle, dx, dy, x, y);
} else {
mouseMove(dx, dy, x, y);
}
}
void MLMultiSlider::mouseDown (const MouseEvent& e)
{
if (!isEnabled()) return;
mMousePos = Vec2(e.x, e.y);
mCurrDragSlider = getSliderUnderPoint(mMousePos);
mouseDrag(e);
}
//! Connects to mouseDown, mouseDrag, mouseWheel and resize signals of \a window, with optional priority \a signalPriority
void CameraUi::connect( const app::WindowRef &window, int signalPriority )
{
mWindow = window;
mSignalPriority = signalPriority;
if( window ) {
mMouseDownConnection = window->getSignalMouseDown().connect( signalPriority,
[this]( app::MouseEvent &event ) { mouseDown( event ); } );
mMouseUpConnection = window->getSignalMouseUp().connect( signalPriority,
[this]( app::MouseEvent &event ) { mouseUp( event ); } );
mMouseDragConnection = window->getSignalMouseDrag().connect( signalPriority,
[this]( app::MouseEvent &event ) { mouseDrag( event ); } );
mMouseWheelConnection = window->getSignalMouseWheel().connect( signalPriority,
[this]( app::MouseEvent &event ) { mouseWheel( event ); } );
mWindowResizeConnection = window->getSignalResize().connect( signalPriority,
[this]() {
setWindowSize( mWindow->getSize() );
if( mCamera )
mCamera->setAspectRatio( mWindow->getAspectRatio() );
}
);
}
else
disconnect();
mLastAction = ACTION_NONE;
}
void mainLoop() {
//The first time you run TackFPS it will return a trash value, so get it out of the way now
TackFPS(true);
//Pre-emptively call the resize and draw functions to get the cycle going
reshape(miWidth, miHeight);
bool running = true;
sf::Event event;
while(running) {
draw();
while(window.pollEvent(event)) {
switch(event.type) {
case sf::Event::Closed: running = false; break;
case sf::Event::Resized: reshape(event.size.width, event.size.height); break;
case sf::Event::KeyPressed: keyDown(event.key.code); break;// TODO codes
case sf::Event::MouseMoved: mouseDrag(event.mouseMove.x, event.mouseMove.y); break;
case sf::Event::MouseButtonPressed: mousePress(event.mouseButton.button, 1, event.mouseButton.x, event.mouseButton.y); break;
case sf::Event::MouseButtonReleased: mousePress(event.mouseButton.button, 0, event.mouseButton.x, event.mouseButton.y); break;
case sf::Event::TextEntered: charTyped(event.text.unicode); break;
default: cout << "unhandled event:" << event.type << endl; break;
}
}
window.display();
}
}
void CameraUi::mouseDrag( app::MouseEvent &event )
{
bool isLeftDown = event.isLeftDown();
bool isMiddleDown = event.isMiddleDown() || event.isAltDown();
bool isRightDown = event.isRightDown() || event.isControlDown();
if( isMiddleDown )
isLeftDown = false;
mouseDrag( event.getPos(), isLeftDown, isMiddleDown, isRightDown );
event.setHandled();
}
//==============================================================================
void Joystick::mouseDown(const MouseEvent& e)
{
mouseWasHidden = false;
if (isEnabled())
{
if (e.mods.isPopupMenu() && menuEnabled)
{
menuShown = true;
PopupMenu m;
m.addItem (1, TRANS ("velocity-sensitive mode"), true, isVelocityBased);
m.addSeparator();
const int r = m.show();
if (r == 1)
{
setVelocityBasedMode (! isVelocityBased);
}
else if (r == 2)
{
// setSliderStyle (RotaryHorizontalDrag);
}
else if (r == 3)
{
// setSliderStyle (RotaryVerticalDrag);
}
}
else if (e.mods.isLeftButtonDown()
|| e.mods.isMiddleButtonDown())
{
menuShown = false;
// unbound mouse movements
if (isVelocityBased)
{
e.source.enableUnboundedMouseMovement (true, false);
mouseWasHidden = true;
}
startPressX = e.x;
startPressY = e.y;
// In case it was a click without a drag, do the drag anyway
mouseDrag (e);
}
// So arrow keys works
grabKeyboardFocus();
}
}
void SplittableWaveDisplay::mouseDown(const MouseEvent &e){
std::cout<<"Clicked \n";
if (!e.mouseWasClicked()){
mouseDrag(e);
}
if(e.mods.isShiftDown()){
if (!e.mods.isAltDown()){
}
}
else{}
waveDisplay.mouseDown(e);
}
bool TreentNode::deepMouseDrag( ci::app::MouseEvent &event )
{
bool captured = false;
auto gui_component = component<GuiComponent>();
if( gui_component )
captured = gui_component->mouseDrag( event, getWorldTransform() );
for( TreentNodeRef &child : mChildren )
{ // stop evaluation if event was captured by self or a child
if( captured )
break;
captured = child->deepMouseDrag( event );
}
return captured;
}
bool Node::treeMouseDrag( MouseEvent event )
{
if(!mIsVisible) return false;
// test children first, from top to bottom
NodeList nodes(mChildren);
NodeList::reverse_iterator itr;
bool handled = false;
for(itr=nodes.rbegin(); itr!=nodes.rend()&&!handled; ++itr)
handled = (*itr)->treeMouseDrag(event);
// if not handled, test this node
if(!handled) handled = mouseDrag(event);
return handled;
}
void MouseThread::threadedFunction() {
Action action;
while (true) {
action.type = NO_ACTION;
lock();
if (next.type != NO_ACTION) {
action = next;
next.type = NO_ACTION;
}
unlock();
switch (action.type) {
case NO_ACTION: {
sleep(100);
break;
}
case MOVE: {
mouseMove(action.x1, action.y1);
sleep(100);
break;
}
case CLICK: {
mouseDown(action.x1, action.y1);
sleep(10);
mouseUp(action.x1, action.y1);
sleep(100);
break;
}
case DRAG: {
mouseDown(action.x1, action.y1);
for (int i = 0; i < 10; ++i) {
sleep(10);
mouseDrag(action.x1 + (action.x2 - action.x1) * i / 10, action.y1 + (action.y2 - action.y1) * i / 10);
}
sleep(10);
mouseUp(action.x2, action.y2);
sleep(400);
break;
}
}
}
}
void SliderBank::mouseDown (const MouseEvent& event)
{
if (event.eventTime - prevMouseDownTime < RelativeTime(MicronSlider::doubleClickDuration))
{ // double-click, initiate default-values painting
resettingValuesToDefault = true;
resetDoubleClickTimer();
}
else
{ // first click, prime for double-click detection
prevMouseDownTime = event.eventTime;
}
// possibly lock onto a particular slider for dragging.
if (event.mods.isRightButtonDown() || ! broadStrokesEnabled)
lockedSliderBeingDragged = findSliderAtPos(event.getPosition());
// let mouseDrag work out which slider to click and manage tracking from there.
mouseDrag(event);
}
void ImageViewer::mouseMoveEvent(QMouseEvent *event) {
QWidget::mouseMoveEvent(event);
if(!mIsDisplaying)
return;
if(event->buttons() & Qt::LeftButton && mouseInteraction != MOUSE_ZOOM) {
if(cursor().shape() != Qt::ClosedHandCursor) {
setCursor(Qt::ClosedHandCursor);
}
mouseInteraction = MOUSE_DRAG;
mouseWrapping ? mouseDragWrapping(event) : mouseDrag(event);
} else if(event->buttons() & Qt::RightButton && mouseInteraction != MOUSE_DRAG) {
// filter out possible mouse jitter by ignoring low delta drags
if(mouseInteraction == MOUSE_ZOOM || abs(mousePressPos.y() - event->pos().y()) > ZOOM_THRESHOLD) {
if(cursor().shape() != Qt::SizeVerCursor) {
setCursor(Qt::SizeVerCursor);
}
mouseInteraction = MOUSE_ZOOM;
mouseMoveZoom(event);
}
}
}
void processCommand(const char *cmd) {
int tmpx, tmpy, btn;
float tmpInterval;
UInt32 tmpkc;
char str[CMD_STRING_MAXLEN];
bzero(str, CMD_STRING_MAXLEN);
if (IS_CMD(cmd, "mouselocation")) {
CGPoint cgLoc = mouseLoc();
printf("%.f %.f\n", cgLoc.x, cgLoc.y);
} else if (IS_CMD(cmd, "mousewarp ")) {
print_msg("Warping mouse to location.");
sscanf(cmd, "mousewarp %d %d", &tmpx, &tmpy);
mouseMove(tmpx, tmpy);
} else if (IS_CMD(cmd, "mousemove ")) {
print_msg("Moving mouse.");
sscanf(cmd, "mousemove %d %d", &tmpx, &tmpy);
mouseMoveTo(tmpx, tmpy, 0.7);
} else if (IS_CMD(cmd, "mousedown")) {
print_msg("Pressing mouse button.");
sscanf(cmd, "mousedown %d", &btn);
mousePress(btn, SINGLE_CLICK);
} else if (IS_CMD(cmd, "mouseup")) {
print_msg("Releasing mouse button.");
sscanf(cmd, "mouseup %d", &btn);
mouseRelease(btn, SINGLE_CLICK);
} else if (IS_CMD(cmd, "mouseclick")) {
print_msg("Clicking mouse.");
sscanf(cmd, "mouseclick %d", &btn);
mouseClick(btn, SINGLE_CLICK);
} else if (IS_CMD(cmd, "mousedoubleclick")) {
print_msg("Double-clicking mouse.");
sscanf(cmd, "mousedoubleclick %d", &btn);
mouseClick(btn, DOUBLE_CLICK);
} else if (IS_CMD(cmd, "mousetripleclick")) {
print_msg("Triple-clicking mouse.");
sscanf(cmd, "mousetripleclick %d", &btn);
mouseClick(btn, TRIPLE_CLICK);
} else if (IS_CMD(cmd, "mousedrag ")) {
print_msg("Dragging mouse.");
sscanf(cmd, "mousedrag %d %d", &tmpx, &tmpy);
mouseDrag(LEFT_MOUSE, tmpx, tmpy);
} else if (IS_CMD(cmd, "press ")) {
print_msg("Pressing key.");
sscanf(cmd, "press %x", &tmpkc);
keyPress((CGKeyCode)tmpkc, NULL);
} else if (IS_CMD(cmd, "release ")) {
print_msg("Releasing key.");
sscanf(cmd, "release %x", &tmpkc);
keyRelease((CGKeyCode)tmpkc, NULL);
} else if (IS_CMD(cmd, "hit ")) {
print_msg("Hitting key.");
sscanf(cmd, "hit %x", &tmpkc);
keyHit((CGKeyCode)tmpkc, NULL);
} else if (IS_CMD(cmd, "type ")) {
print_msg("Typing.");
strncpy(str, &cmd[5], CMD_STRING_MAXLEN);
typeString(str);
} else if (IS_CMD(cmd, "wait")) {
print_msg("Waiting.");
sscanf(cmd, "wait %f", &tmpInterval);
usleep(1000000 * tmpInterval);
} else {
print_msg("I don't know what you want to do.");
}
}
void DDContainer::onMouseDrag(int _left, int _top, MouseButton _id)
{
mouseDrag(_id);
Base::onMouseDrag(_left, _top, _id);
}
void XGraphicsView::mouseMoveEvent(QMouseEvent* event) {
QGraphicsView::mouseMoveEvent(event);
if (clicked_) emit mouseDrag(event);
}
void Gdc2005Demo::handleUserInput(struct GdcStateInput& stateInput)
{
const hkgKeyboard& keys = m_env->m_window->getKeyboard();
// Show help on the keys if the user asks for it
if ( keys.getKeyState('H') ||
keys.getKeyState(HKG_VKEY_F1) ||
( m_env->m_gamePad->isButtonPressed(HKG_PAD_BUTTON_L1)
&& m_env->m_gamePad->isButtonPressed(HKG_PAD_BUTTON_R1)
&& m_env->m_gamePad->isButtonPressed(HKG_PAD_BUTTON_0) )
)
{
showKeys();
}
// For reference, on PC keyboard:
// HKG_VKEY_DELETE == HKG_PAD_BUTTON_L1
// HKG_VKEY_END == HKG_PAD_BUTTON_R1
// HKG_VKEY_INSERT == HKG_PAD_BUTTON_L2
// HKG_VKEY_HOME == HKG_PAD_BUTTON_R2
// See if we want to chuck anything into the scene
if ( m_env->m_gamePad->wasButtonPressed(HKG_PAD_BUTTON_2) )
{
hkVector4 startPos;
m_env->m_window->getCurrentViewport()->getCamera()->getFrom( (float*)&startPos );
hkVector4 velocity;
m_env->m_window->getCurrentViewport()->getCamera()->getDir( (float*)&velocity );
velocity.mul4( m_options.m_Physics.m_launchVelocity );
chuckSomething( startPos, velocity );
}
// See if we want to shot the guy (right click or L2)
if ( m_env->m_gamePad->isButtonPressed(HKG_PAD_BUTTON_L2) ||
(m_env->m_window->getMouse().getButtonState() & HKG_MOUSE_RIGHT_BUTTON) )
{
hkVector4 rayStart;
hkVector4 rayEnd;
// unproject current 'mouse' pos.
hkgCamera* cam = m_env->m_window->getViewport(0)->getCamera();
int xPos = m_env->m_window->getMouse().getPosX();
int yPos = m_env->m_window->getMouse().getPosY();
cam->unProject( xPos, yPos, 0, m_env->m_window->getWidth(), m_env->m_window->getHeight(), (float*)&rayStart);
cam->unProject( xPos, yPos, 1, m_env->m_window->getWidth(), m_env->m_window->getHeight(), (float*)&rayEnd);
fireShot( rayStart, rayEnd, m_options.m_Physics.m_shotStrength ); // num == strength
}
// See if we want to drag objects around
if( !m_mouseActive && ( m_env->m_gamePad->wasButtonPressed(HKG_PAD_BUTTON_R1) ||
keys.getKeyState(HKG_VKEY_SPACE)) ) // Space == Button0 on PC == jump
{
mouseDown(); // pick object under cursor
}
else if ( m_mouseActive )
{
if( !m_env->m_gamePad->isButtonPressed(HKG_PAD_BUTTON_R1) &&
!m_env->m_window->getKeyboard().getKeyState(HKG_VKEY_SPACE) )
{
mouseUp(); // default physics game impl : delete mouse spring
}
else
{
mouseDrag(); // default physics game impl : unproject mouse and move spring.
}
}
// Desired direction
// If we are on a console we are using a stick and want that to dictate
// the desired direction. Otherwise we will use the dpad ( keyboard dir keys )
updateUserControl();
// Die ? Get up? Jump?
{
const hkUint32 currentAnimationState = m_animationStateMachine->getCurrentState();
const bool usingGamepad = m_env->m_window->hasGamePads() && !m_env->m_options->m_forceKeyboardGamepad;
// DIE?
if (m_env->m_gamePad->wasButtonPressed(HKG_PAD_BUTTON_1) && currentAnimationState != GDC_DYING_STATE && currentAnimationState != GDC_DEAD_STATE && currentAnimationState != GDC_GETTING_UP_STATE)
{
stateInput.m_shouldDie = true;
}
else
{
stateInput.m_shouldDie = false;
}
// DIVE?
if (m_env->m_gamePad->wasButtonPressed(HKG_PAD_BUTTON_3) && currentAnimationState != GDC_DYING_STATE && currentAnimationState != GDC_DEAD_STATE && currentAnimationState != GDC_GETTING_UP_STATE)
{
stateInput.m_shouldDive = true;
}
else
{
stateInput.m_shouldDive = false;
}
// GET UP?
if (m_env->m_gamePad->wasButtonPressed(HKG_PAD_BUTTON_1) && currentAnimationState == GDC_DEAD_STATE)
{
stateInput.m_shouldGetUp = true;
}
else
{
stateInput.m_shouldGetUp = false;
}
// JUMP?
bool jumpPressed;
if (usingGamepad)
{
jumpPressed = m_env->m_gamePad->wasButtonPressed(HKG_PAD_BUTTON_0);
}
else
{
jumpPressed = keys.wasKeyPressed('4');
}
if (jumpPressed && currentAnimationState!=GDC_DYING_STATE && currentAnimationState!=GDC_IN_AIR_STATE && currentAnimationState!=GDC_DEAD_STATE && currentAnimationState!=GDC_JUMP_STATE)
{
stateInput.m_shouldJump = true;
}
else
{
stateInput.m_shouldJump = false;
}
}
}
void DDContainer::notifyInvalideDrop(DDContainer* _sender)
{
mouseDrag( mDropButton );
}
void mouseDown (const MouseEvent& e)
{
mouseDrag (e);
}
void ItemBox::notifyMouseDrag(Widget* _sender, int _left, int _top, MouseButton _id)
{
mouseDrag(_id);
}
void ParamGraph::mouseDown(const MouseEvent& event){
mouseDrag(event);
}
void mouseDown (const MouseEvent& e) override
{
mouseDrag (e);
}
void ListCtrl::notifyMouseDrag(Widget* _sender, int _left, int _top)
{
mouseDrag();
}
