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();
}
}
PhotoStripView::PhotoStripView(PhotoStrip *controller) :
MWidgetView(controller),
controller(controller),
viewport(new Viewport),
mainLayout(new QGraphicsLinearLayout(Qt::Horizontal)),
pannedWidget(new QGraphicsWidget),
focusedWidget(-1), _isPositionChanged(false),
isModelRowChanged(false), currentModel(0),
mode(PhotoStripView::OnNormal)
{
/* controller initial setting */
controller->setContentsMargins(0, 0, 0, 0);
controller->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
/* pannable viewport initial setting */
viewport->setObjectName("PhotoStripDetailsViewport");
viewport->setPanDirection(Qt::Horizontal);
viewport->setContentsMargins(0, 0, 0, 0);
viewport->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
viewport->setAutoRange(false);
/* the layout of viewport initial setting */
mainLayout->setSpacing(0);
mainLayout->setContentsMargins(0, 0, 0, 0);
mainLayout->addItem(viewport);
controller->setLayout(mainLayout);
/* pannedWidget initial setting */
pannedWidget->setContentsMargins(0, 0, 0, 0);
pannedWidget->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
/* pannedLayout initial setting */
pannedLayout = new PhotoStripLayout();
pannedWidget->setLayout(pannedLayout);
pannedLayout->setSpacing(ITEM_SPACING);
pannedLayout->setContentsMargins(0, 0, 0, 0);
connect(viewport, SIGNAL(sizePosChanged(const QSizeF &, const QRectF &, const QPointF &)),
this, SLOT(sizePosChanged(const QSizeF &, const QRectF &, const QPointF &)));
viewport->setWidget(pannedWidget);
viewport->positionIndicator()->hide();
physics = new PhotoStripPhysics(this);
connect(physics, SIGNAL(snapIndexChanged(int)), this, SLOT(snapIndexChanged(int)));
viewport->setPhysics(physics);
connect(viewport, SIGNAL(panningStopped()), this, SLOT(panningStopped()));
timer = new QTimer(this);
connect(timer, SIGNAL(timeout()), this, SLOT(showNextImage()));
timer->setInterval(SLIDESHOW_INTERVAL);
connect(viewport, SIGNAL(mousePress()), this, SLOT(mousePress()));
}
void Qt5GLWidget::mousePressEvent(QMouseEvent* event) {
m_x = event->x();
m_y = m_height - event->y() - 1;
m_startX = m_x;
m_startY = m_y;
switch (event->button()) {
case Qt::LeftButton: m_leftDown = true; mousePress(Left, m_x, m_y); break;
case Qt::RightButton: m_rightDown = true; mousePress(Right, m_x, m_y); break;
case Qt::MidButton: m_middleDown = true; mousePress(Middle, m_x, m_y); break;
default: break;
}
}
void DockAppIcon::mousePressEvent(QMouseEvent *ev)
{
if (m_modeData->getDockMode() == Dock::FashionMode)
emit mousePress(ev);
else
QLabel::mousePressEvent(ev);
}
/**
* \brief Default constructor
*/
Worker::Worker(RoboCompKinect::KinectPrx kinectprx, QObject *parent) : Ui_evaluacionForm()
{
kinect = kinectprx;
mutex = new QMutex();
ippSetNumThreads(1);
setupUi(this);
imgAlto=480;imgAncho=640;
maxDepth=10.0;minDepth=0.5;
ippSizeImage.height=imgAlto;
ippSizeImage.width=imgAncho;
qImgRGB = new QImage(imgAncho,imgAlto,QImage::Format_RGB888 );
qImgRGBZ = new QImage(imgAncho,imgAlto,QImage::Format_RGB888 );
qImgZ = new QImage(imgAncho,imgAlto,QImage::Format_Indexed8 );
imgZ =ippsMalloc_8u(imgAlto*imgAncho);
rcdRGB = new RCDraw (imgAncho,imgAlto,qImgRGB,this->frameRGB);
rcdRGBZ = new RCDraw (imgAncho,imgAlto,qImgRGBZ,this->frameRGBZ);
rcdZ = new RCDraw (imgAncho,imgAlto,qImgZ,this->frameZ);
roiGrab.setCoords(0,0,640,480);
grab=false;capture=false;
show();
connect(&timer, SIGNAL(timeout()), this, SLOT(compute()));
connect(rcdZ,SIGNAL(newCoor(QPointF)),this,SLOT(mousePress(QPointF)));
connect(rcdZ,SIGNAL(endCoor(QPointF)),this,SLOT(mouseRelase(QPointF)));
Period = BASIC_PERIOD;
timer.start(Period);
}
void WorldEdit::Update()
{
if (keyboardPress(sf::Keyboard::Escape))
GC->GSNext = Paul::MM;
UpdateFlash();
sf::FloatRect BoundingBox;
for (int i = 0; i < Squares.size(); i++)
{
for (int j = 0; j < Squares[i].size(); j++)
{
if (Squares[i][j].getGlobalBounds().contains(GC->currentMousePosition.x, GC->currentMousePosition.y))
{
if (mousePress(LeftMouseButton))
SquareColor[i][j] = sf::Color::Red;
Squares[i][j].setFillColor(sf::Color(SquareColor[i][j].r, SquareColor[i][j].g, SquareColor[i][j].b, FlashAlphaColor));
}
else
Squares[i][j].setFillColor(SquareColor[i][j]);
}
}
}
void DockAppItem::onMousePress(QMouseEvent *event)
{
Q_UNUSED(event)
hidePreview(true);
emit mousePress();
}
bool QgsGraduatedHistogramEventFilter::eventFilter( QObject *object, QEvent *event )
{
switch ( event->type() )
{
case QEvent::MouseButtonPress:
{
const QMouseEvent* mouseEvent = static_cast<QMouseEvent* >( event );
if ( mouseEvent->button() == Qt::LeftButton )
{
emit mousePress( posToValue( mouseEvent->pos() ) );
}
break;
}
case QEvent::MouseButtonRelease:
{
const QMouseEvent* mouseEvent = static_cast<QMouseEvent* >( event );
if ( mouseEvent->button() == Qt::LeftButton )
{
emit mouseRelease( posToValue( mouseEvent->pos() ) );
}
break;
}
default:
break;
}
return QObject::eventFilter( object, event );
}
/**
* \brief When we press a button on the mouse
* left click : begin the draw of a boundingbox
* right cick : remove the rectangles we clicked
* \author Jules Gorny - ALCoV team, ISIT, UMR 6284 UdA – CNRS
**/
void QImageLabel::mousePressEvent(QMouseEvent * event)
{
if(event->button() == Qt::LeftButton)
mousePress(event->pos().x(), event->pos().y());
else if(event->button() == Qt::RightButton)
deleteRect(event->pos().x(), event->pos().y());
}
bool FrameLess::eventFilter(QObject *o, QEvent*e) {
if (e->type() == QEvent::MouseMove ||
e->type() == QEvent::HoverMove ||
e->type() == QEvent::Leave ||
e->type() == QEvent::MouseButtonPress ||
e->type() == QEvent::MouseButtonRelease) {
switch (e->type())
{
case QEvent::MouseMove:
mouseMove(static_cast<QMouseEvent*>(e));
return true;
break;
case QEvent::HoverMove:
mouseHover(static_cast<QHoverEvent*>(e));
return true;
break;
case QEvent::Leave:
mouseLeave(e);
return true;
break;
case QEvent::MouseButtonPress:
mousePress(static_cast<QMouseEvent*>(e));
return true;
break;
case QEvent::MouseButtonRelease:
mouseRealese(static_cast<QMouseEvent*>(e));
return true;
break;
}
} else {
return false;
}
}
QGraphContainer::QGraphContainer(MyQGraphicsView* ctrl, QPaintDevice* _dev):GraphContainer<QGraphicsModel>(ctrl), dev(ctrl), painter(_dev)
{
this->dWidth = 1;
this->dHeight= 1;
edgesToDraw = new EdgeInfo[0];// for preventing if
for(int i=0; i<3; ++i){
selectedEdgeDescriptor[i] = 0;
}
connect(this, SIGNAL(callRepaint()), ctrl, SLOT(repaint()));
connect(ctrl, SIGNAL(mouseMoveE(QPointF)), this, SLOT(mouseMove(QPointF)));
connect(ctrl, SIGNAL(mousePressE(QPointF)), this, SLOT(mousePress(QPointF)));
currentTick=0;
QObject::connect(&timer, SIGNAL(timeout()), this, SLOT(invokeDraw()));
point points[] = {point (-50, 0, 0), point (-100, 50, 0), point (-150, 100, 0), point(-50, 130, 0), point(-250, 150, 100), point(-50, 180, 100), point(-20, 200, 0)};
float mass[] = {1, 1, 3, 1, 2, 2, 1};
devWidth = _dev->width();
devHeight = _dev->height();
colorField = new ColorPixel*[devHeight];
for(int i=0; i<devHeight; ++i){
colorField[i] = new ColorPixel[devWidth];
for(int j=0; j<devWidth; ++j){
colorField[i][j].colors = 0;
colorField[i][j].intensity = 0;
}
}
//this->collection.push_back(new RationalCurve(points, mass, 7, 100, 20, 20));
this->collection.push_back(new Conus(250, 150, 20, 20));
}
void
ImageView::mousePressEvent( QMouseEvent * e )
{
if ( !_imagePosition.contains(e->pos()) ) return;
*e = mapMousePositionToImage( e );
emit mousePress( e );
}
/**
* Event delegation
*
* @param e The event to be identified and processed
*
*/
bool ConnectorTool::processEvent(QEvent* e)
{
switch (e->type())
{
case QEvent::MouseButtonPress:
mousePress( static_cast<QMouseEvent*>(e) );
return true;
break;
case QEvent::MouseButtonRelease:
mouseRelease( static_cast<QMouseEvent*>(e) );
return true;
break;
case QEvent::MouseMove:
mouseMove( static_cast<QMouseEvent*>(e) );
return true;
break;
default:
break;
}
return false;
}
/**
* Event delegation
*
* @param e The event to be identified and processed
*
*/
bool SMLConnector::processEvent( QEvent* e )
{
switch (e->type())
{
case QEvent::MouseButtonPress:
mousePress( (QMouseEvent*)e );
return true;
break;
case QEvent::MouseButtonRelease:
mouseRelease( (QMouseEvent*)e );
return true;
break;
case QEvent::MouseMove:
mouseMove( (QMouseEvent*)e );
return true;
break;
default:
break;
}
return false;
}
void QIrrlichtWidget::mousePressEvent(QMouseEvent *event)
{
mouseX = event->x();
mouseY = event->y();
mousePressed = true;
emit(mousePress(event));
}
void Nentry::mouseDoubleClick(QMouseEvent* event)
{
if (event->button() != Qt::LeftButton)
{
mousePress(event);
return;
}
}
void TwoDRenderer::mousePressEvent( QMouseEvent* event )
{
// fixing the moment when the mouse button is pressed down
_timeStartMousePress = QTime::currentTime();
emit mousePress( event );
QGraphicsView::mousePressEvent( event );
}
void DArrowButton::mousePressEvent(QMouseEvent *event)
{
Q_UNUSED(event)
emit mousePress();
m_normalLabel->setVisible(false);
m_hoverLabel->setVisible(false);
m_pressLabel->setVisible(true);
setButtonState(DArrowButton::ArrowStatePress);
}
bool TargetTool::processEvent(QEvent* e)
{
if(e->type() == QEvent::MouseButtonPress) {
mousePress(static_cast<QMouseEvent*>(e));
return true;
} else if(e->type() == QEvent::MouseMove) {
mouseMove(static_cast<QMouseEvent*>(e));
return true;
}
return false;
}
int inputManager::update(void)
{
SDL_Event currentEvent;
while ( !messageP.empty() )
{
AssetManager::lockMutex( inputManager::mutex_event );
currentEvent = messageP.receiveMessage();
AssetManager::unlockMutex( inputManager::mutex_event );
if (currentEvent.type == SDL_ACTIVEEVENT)
{
if ( currentEvent.active.state & SDL_APPINPUTFOCUS )
{
if (currentEvent.active.gain==0)
{
active = false;
SDL_WM_GrabInput(SDL_GRAB_OFF);
SDL_ShowCursor(SDL_ENABLE);
}
else
{
active = true;
SDL_ShowCursor(SDL_DISABLE);
SDL_WM_GrabInput(SDL_GRAB_ON);
}
}
}
if (active)
{
switch (currentEvent.type)
{
case SDL_KEYDOWN:
case SDL_KEYUP:
keyPress(currentEvent);
break;
case SDL_MOUSEBUTTONDOWN:
case SDL_MOUSEBUTTONUP:
mousePress(currentEvent);
break;
case SDL_MOUSEMOTION:
mouseMotion(currentEvent);
break;
default:
break;
}
}
}
return 0;
}
int MonthLineEdit::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QLineEdit::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: mousePress((*reinterpret_cast< bool(*)>(_a[1]))); break;
default: ;
}
_id -= 1;
}
return _id;
}
void ossimGui::ImageScrollWidget::mousePressEvent ( QMouseEvent * e )
{
QScrollArea::mousePressEvent(e);
m_activePointStart = e->pos();
m_activePointEnd = e->pos();
if(!m_inputBounds.hasNans())
{
ossimIpt origin = m_inputBounds.ul();
ossimIpt localPoint(m_scrollOrigin.x +e->x(), m_scrollOrigin.y+e->y());
ossimIpt viewPoint(localPoint.x+origin.x,
localPoint.y+origin.y);
ossimDrect rect = viewportBoundsInViewSpace();
// Save the measured point position
// (viewPoint = view<-scroll<-local)
ossim_uint32 idxLayer = 0;
ossimImageSource* src = m_layers->layer(idxLayer)->chain();
ossimGui::GatherImageViewProjTransVisitor visitor;
src->accept(visitor);
if (visitor.getTransformList().size() == 1)
{
// Transform to true image coordinates and save
ossimRefPtr<IvtGeomTransform> ivtg = visitor.getTransformList()[0].get();
if (ivtg.valid())
{
ivtg->viewToImage(viewPoint, m_measImgPoint);
}
}
m_measPoint = viewPoint;
m_drawPts = true;
update();
// m_regOverlay->setMeasPoint(m_measPoint);
// cout << "\n ImageScrollWidget::mousePressEvent ("
// << viewPoint.x << ", "<< viewPoint.y << ") ("
// << m_measImgPoint.x << ", "<< m_measImgPoint.y << ")"
// << endl;
emit mousePress(e, rect, viewPoint);//viewportPoint, localPoint, viewPoint);
}
}
void ScreenGrabberChooserRectItem::forwardMainRectEvent(QEvent* event)
{
QGraphicsSceneMouseEvent* mouseEvent = static_cast<QGraphicsSceneMouseEvent*>(event);
switch(event->type())
{
case QEvent::GraphicsSceneMousePress:
return mousePress(mouseEvent);
case QEvent::GraphicsSceneMouseMove:
return mouseMove(mouseEvent);
case QEvent::GraphicsSceneMouseRelease:
return mouseRelease(mouseEvent);
case QEvent::GraphicsSceneMouseDoubleClick:
return mouseDoubleClick(mouseEvent);
default:
return;
}
}
void MainMenu::Update()
{
if (GC->currentMousePosition != GC->previousMousePosition)
{
for (int i = 0; i < BoundingBoxes.size(); i++)
if (BoundingBoxes[i].contains(GC->currentMousePosition.x, GC->currentMousePosition.y))
Selected = i;
}
if (keyboardPress(sf::Keyboard::Escape))
GC->window.close();
if (keyboardPress(sf::Keyboard::Up))
Selected = (Selected + Options.size() - 1) % Options.size();
if (keyboardPress(sf::Keyboard::Down))
Selected = (Selected + 1) % Options.size();
if (keyboardPress(sf::Keyboard::Return) ||
mousePress(LeftMouseButton))
SwitchState(Selected);
}
void ui_container::mousePress(QMouseEvent *mouse)
{
for(int cou = elements.size() - 1; cou >=0; cou--)
{
auto i = elements[cou];
auto p = i->get_position();
QRect rect(p, i->size);
if(rect.contains(mouse->pos()))
{
for(int j = cou; j < elements.size() - 1; j++)
{
std::swap(elements[j], elements[j + 1]);
}
i->mousePress(mouse);
break;
}
}
}
void processEvent(sf::Event& event) {
switch(event.type) {
case sf::Event::Closed: {
window->close();
break;
}
case sf::Event::KeyPressed: {
keyDown(event.key.code);
break;
}
case sf::Event::KeyReleased: {
keyUp(event.key.code);
break;
}
case sf::Event::MouseButtonPressed: {
mousePress(event.mouseButton.button, event.mouseButton.x, event.mouseButton.y);
break;
}
}
}
void Button::mousePressEvent(QMouseEvent*ev) {
/*
* Shift + Left-Click activate the midi learn widget
*/
if ( ev->button() == Qt::LeftButton && (ev->modifiers() & Qt::ShiftModifier) ){
MidiSenseWidget midiSense( this, true, this->getAction() );
midiSense.exec();
return;
}
m_bPressed = true;
update();
emit mousePress(this);
if ( ev->button() == Qt::LeftButton && __enable_press_hold) {
m_timerTimeout = 2000;
buttonPressed_timer_timeout();
}
}
void QWidgetExtended::signalEvent(QMouseEvent *event, int code) {
QFrameExtended frame;
QWidget *widget = this->childAt(event->pos());
if (widget != NULL) {
QString widgetClassName(widget->metaObject()->className());
//I don't use explicitly the string because if one day someone changes the name of the class, the compiler will output an error
QString className(frame.metaObject()->className());
if (widgetClassName == className) {
switch(code) {
case PRESSED:
emit mousePress(dynamic_cast<QFrameExtended*> (widget));
break;
case RELEASED:
emit mouseRelease(dynamic_cast<QFrameExtended*> (widget));
break;
case MOVED:
emit mouseMove(dynamic_cast<QFrameExtended*> (widget));
break;
}
}
}
}
void OpenGL2Common::dispatchEvent(QEvent *e, QObject *p)
{
switch (e->type())
{
case QEvent::MouseButtonPress:
if (sphericalView)
mousePress360((QMouseEvent *)e);
else
mousePress((QMouseEvent *)e);
break;
case QEvent::MouseButtonRelease:
if (sphericalView)
mouseRelease360((QMouseEvent *)e);
else
mouseRelease((QMouseEvent *)e);
break;
case QEvent::MouseMove:
if (sphericalView)
mouseMove360((QMouseEvent *)e);
else
mouseMove((QMouseEvent *)e);
break;
case QEvent::Resize:
newSize(((QResizeEvent *)e)->size());
break;
case QEvent::TouchBegin:
case QEvent::TouchUpdate:
canWrapMouse = false;
//Pass through
case QEvent::TouchEnd:
case QEvent::Gesture:
/* Pass gesture and touch event to the parent */
QCoreApplication::sendEvent(p, e);
break;
default:
break;
}
}
void CenterImageView::mousePressEvent(QMouseEvent *event)
{
last_click = event->pos();
emit mousePress(event);
}
