Example #1
0
KisGridConfig GridConfigWidget::fetchGuiGridConfig() const
{
    KisGridConfig config;

    config.setShowGrid(ui->chkShowGrid->isChecked());
    config.setSnapToGrid(ui->chkSnapToGrid->isChecked());

    QPoint pt;

    pt.rx() = ui->intHSpacing->value();
    pt.ry() = ui->intVSpacing->value();
    config.setSpacing(pt);

    pt.rx() = ui->intXOffset->value();
    pt.ry() = ui->intYOffset->value();
    config.setOffset(pt);

    config.setSubdivision(ui->intSubdivision->value());

    config.setOffsetAspectLocked(ui->offsetAspectButton->keepAspectRatio());
    config.setSpacingAspectLocked(ui->spacingAspectButton->keepAspectRatio());

    config.setLineTypeMain(KisGridConfig::LineTypeInternal(ui->selectMainStyle->currentIndex()));
    config.setLineTypeSubdivision(KisGridConfig::LineTypeInternal(ui->selectSubdivisionStyle->currentIndex()));

    config.setColorMain(ui->colorMain->color());
    config.setColorSubdivision(ui->colorSubdivision->color());

    return config;
}
Example #2
0
MapEditorPopup::MapEditorPopup(QPoint pos,QPointF value, int i,QWidget * parent)
    :QWidget(parent)
//  :QWidget(parent,Qt::Popup)
//  :QDialog(parent,Qt::Popup)
{
  index = i;
  pos.rx() += 5;
  pos.ry() -= 5;
  QGridLayout * layout = new QGridLayout;
  layout->addWidget(new QLabel("Iteration:"),1,0);
  xEdit = new QLineEdit;
  xEdit->setText(QString::number(value.x(),'g',6));
  xEdit->setMaximumWidth(80);
  QDoubleValidator * sv = new QDoubleValidator(xEdit);
  sv->setNotation(QDoubleValidator::ScientificNotation);
  xEdit->setValidator(sv);

  layout->addWidget(xEdit,1,1);
  layout->addWidget(new QLabel("Value:"),0,0);
  yEdit = new QLineEdit;
  yEdit->setText(QString::number(value.y(),'g',6));
  yEdit->setMaximumWidth(80);
  sv = new QDoubleValidator(yEdit);
  sv->setNotation(QDoubleValidator::ScientificNotation);
  yEdit->setValidator(sv);

  layout->addWidget(yEdit,0,1);
  setLayout(layout);
  pos.ry() -= sizeHint().height()/2;
  //  move(parent->mapToGlobal(pos));
  move(pos);
  xEdit->setFocus(Qt::ActiveWindowFocusReason);
  //  setAttribute(Qt::WA_DeleteOnClose,true);
}
void AdmScrollAreaSmoothDrag::sDragEnterEvent(AdmExtensionWidget *obj, QDragEnterEvent *event)
{
  // Make sure the timer is not going and we are scrollable
  if(_timer == NULL && _scrollDir == ScrollOff && verticalScrollBar()->isVisible() && height() >= ScrollMinHeight)
  {
    // Get the mouse position
    _pointDragMoveEvent = mapTo(this,event->pos());
    QPoint eventPos = event->pos();

    // Determine the region of the mouse position
    if((eventPos.ry()+obj->y())-verticalScrollBar()->value() <= ScrollRegionHeight)
    {
      // Test for upper region and start the scroll timer scrolling up
      _scrollDir = ScrollUp;
      _timer = new QTimer();
      connect(_timer,SIGNAL(timeout()),this,SLOT(sTickTock()));
      _timer->start(ScrollTimerTimout);
    } else if (rect().height() + verticalScrollBar()->value() - (eventPos.ry()+obj->y()) <= ScrollRegionHeight) {
      // Test for lower region and start the scroll timer scrolling down
      _scrollDir = ScrollDown;
      _timer = new QTimer();
      connect(_timer,SIGNAL(timeout()),this,SLOT(sTickTock()));
      _timer->start(ScrollTimerTimout);
    }
  }
}
void SyszuxIM::updateHandler(int type)
{
    switch(type)
    {
    case QWSInputMethod::FocusIn:
    {
        QWidget *currentWidget = new QWidget;
        QWidget *parentWidget = new QWidget;
        currentWidget = QApplication::focusWidget();
        parentWidget = currentWidget->parentWidget();
        QPoint globalPoint (currentWidget->mapToGlobal(QPoint(0,0)));             //  获取控件在窗体中的坐标
        QPoint parentGlobalPoint (parentWidget->mapToGlobal(QPoint(0,0)));
        if ( globalPoint.ry() > 239)                     //输入法遮挡了当前要输入的窗口部件
        {
            widgetMoveY = globalPoint.ry() - 239 + parentGlobalPoint.ry();

            parentWidget->move(0,-widgetMoveY);
            // qDebug() << "move"<<(-widgetMoveY);
        }

        syszuxpinyin->show();
    }
    break;

    case QWSInputMethod::FocusOut:
    {

        syszuxpinyin->hide();
    }
    break;
    default:
        break;
    }

}
Example #5
0
void Oubliette::keyPressEvent(QKeyEvent *ke)
{
    QPoint newPos = m_character.position();
    switch (ke->key()) {
    case Qt::Key_Up:
    case Qt::Key_K:
        newPos.ry() -= 1;
        break;
    case Qt::Key_Down:
    case Qt::Key_J:
        newPos.ry() += 1;
        break;
    case Qt::Key_Left:
    case Qt::Key_H:
        newPos.rx() -= 1;
        break;
    case Qt::Key_Right:
    case Qt::Key_L:
        newPos.rx() += 1;
        break;
    case Qt::Key_I:
        showInventory();
        break;
    default:
        QWidget::keyPressEvent(ke);
    }
    if (tryMove(newPos)) {
        QRect r(QPoint((newPos.x() - 8) * TileWidth, (newPos.y() - 8) * TileHeight),
                QSize(24 * TileWidth, 24 * TileHeight));
        update(r);
        emit characterMoved(visualCursorPos());
    }
}
Example #6
0
void TimeLine::wheelEvent(QWheelEvent* event)
{

    QPoint numPixels = event->pixelDelta();
    QPoint numDegrees = event->angleDelta() / 8;
    int isForward =0;
    if (!numPixels.isNull()) {
        if (numPixels.ry()>0)
          isForward =1;
        else if (numPixels.ry()<0)
          isForward =-1;
    }
    else if (!numDegrees.isNull()) {
        if (numDegrees.ry()>0)
            isForward =1;
        else if (numDegrees.ry()<0)
            isForward =-1;
    }

    if (isForward >0)
        mVScrollbar->triggerAction(QAbstractSlider::SliderSingleStepAdd);
    else if (isForward <0)
        mVScrollbar->triggerAction(QAbstractSlider::SliderSingleStepSub);
    else
    {
      //Do nothing we've had a wheel event where we are neither going forward or backward
      //which should never happen?
    }

    event->accept();
}
Example #7
0
void Canvas::drawGraph(int n)
{
    pixmap.fill(Qt::white);
    QPainter painter(&pixmap);
    painter.setRenderHint(QPainter::Antialiasing, true);

    const int R = 3;
    std::vector<QPoint> points = getPoints(n);

    painter.setPen(QPen(QBrush(Qt::black), 0.5));
    for (size_t i = 0; i < points.size(); ++i) {
        for (size_t j = i; j < points.size(); ++j) {
            painter.drawLine(points[i], points[j]);
        }
    }

    painter.setPen(Qt::black);
    painter.setBrush(QBrush(Qt::black));
    for (size_t i = 0; i < points.size(); ++i) {
        painter.drawEllipse(points[i].rx() - R, points[i].ry() - R, 2*R, 2*R);

        QPoint c =  geometry().center();
        int labelX = (int)(1.12*(points[i].rx() - c.rx())) + c.rx() - 4;
        int labelY = (int)(1.12*(points[i].ry() - c.ry())) + c.ry() + 5;

        painter.drawText(QPoint(labelX, labelY), QString("%1").arg(i));
    }
}
void OBSBasic::on_volCtrlBtn_released()
{
	QPoint pt = QCursor::pos();
	//悬浮在鼠标上方的位置
	pt.setY(pt.ry() - ui->volCtrlBtn->height() / 2);
	m_pHoverVolCtrlWidget->ShowAt(pt.rx(), pt.ry());
}
QPoint GeneralManager::getPatchCoordinate(QPointF scenePoint){
    QPoint patchCoordinate;

	int patchSizeMinusOverlap = parameter.patchSizeLower - parameter.OverlapSizeLower;

    patchCoordinate.setX(scenePoint.rx()/patchSizeMinusOverlap);
    patchCoordinate.setY(scenePoint.ry()/patchSizeMinusOverlap);

	int PatchStepLower = parameter.patchSizeLower - parameter.OverlapSizeLower;

	int NumWidLower = (parameter.imageCol- parameter.patchSizeLower)/PatchStepLower + 1;
	int NumHeiLower = (parameter.imageRol- parameter.patchSizeLower)/PatchStepLower + 1;

    //compute too Right and too Bottom case
    cout << "too Right? " << patchCoordinate.rx() << "/\n";// << Sketch->NumWidLower - 1 << endl;
    if (patchCoordinate.rx() > NumWidLower - 1){
        //cout << "At too Right" << endl;
        patchCoordinate.setX(NumWidLower - 1);
    }
    cout << "too Bottom? " << patchCoordinate.ry() << "/\n";// << Sketch->NumHeiLower - 1 << endl;
    if (patchCoordinate.ry() > NumHeiLower - 1){
        //cout << "At too Bottom" << endl;
        patchCoordinate.setY(NumHeiLower - 1);
    }

    return patchCoordinate;

}
Example #10
0
void SourceImage::mouseMoveEvent(QMouseEvent *event)
{
    if(event->buttons() &Qt::LeftButton)
    {
        if(boundary.isEmpty())
        {
            boundary<<event->pos();
            return;
        }

        QPoint oldpos = boundary.last();
        QPoint newpos = event->pos();
        qDebug()<<event->pos();
        if(((oldpos.rx()-newpos.rx())<=1)
                &&((oldpos.rx()-newpos.rx())>=-1)
                &&((oldpos.ry()-newpos.ry())<=1)
                &&((oldpos.ry()-newpos.ry())>=-1))
            boundary<<newpos;
        else
        {
            linkPoint(oldpos, newpos);
            boundary<<newpos;
        }
        this->update();
    }
}
Example #11
0
void
SegmentTip::moveTo(QPoint p, QWidget &canvas, bool placeAbove)
{
    //**** this function is very slow and seems to be visibly influenced by operations like mapFromGlobal() (who knows why!)
    //  ** so any improvements are much desired

    //TODO uints could improve the class
    p.rx() -= rect().center().x();
    p.ry() -= (placeAbove ? 8 + height() : m_cursorHeight - 8);

    const QRect screen = KGlobalSettings::desktopGeometry(parentWidget());

    const int x  = p.x();
    const int y  = p.y();
    const int x2 = x + width();
    const int y2 = y + height(); //how's it ever gunna get below screen height?! (well you never know I spose)
    const int sw = screen.width();
    const int sh = screen.height();

    if (x  < 0 ) p.setX(0);
    if (y  < 0 ) p.setY(0);
    if (x2 > sw) p.rx() -= x2 - sw;
    if (y2 > sh) p.ry() -= y2 - sh;


    //I'm using this QPoint to determine where to offset the bitBlt in m_pixmap
    QPoint offset = canvas.mapToGlobal(QPoint()) - p;
    if (offset.x() < 0) offset.setX(0);
    if (offset.y() < 0) offset.setY(0);


    const QRect alphaMaskRect(canvas.mapFromGlobal(p), size());
    const QRect intersection(alphaMaskRect.intersect(canvas.rect()));

    m_pixmap = QPixmap(size()); //move to updateTip once you are sure it can never be null

    const QColor c = QToolTip::palette().color(QPalette::Active, QPalette::Background);
    if (!m_backing_store)
        m_pixmap.fill(c);

    QPainter paint(&m_pixmap);
    paint.setPen(Qt::black);
    paint.setBrush(Qt::NoBrush);
    paint.drawRect(rect());
    paint.end();

    /* if (m_backing_store)
        m_pixmap = QPixmap::fromImage(Blitz::fade(m_pixmap.toImage() , 0.6f, c)); */ // TODO: reimplement this

    paint.begin(&m_pixmap);
    paint.drawText(rect(), Qt::AlignCenter, m_text);
    paint.end();

    p += screen.topLeft(); //for Xinerama users

    move(x, y);
    show();
    update();
}
void BbVideoWindowControl::updateVideoPosition()
{
    if (m_context && m_videoId != -1 && m_widget) {
        QPoint topLeft = m_fullscreen ?
                                   QPoint(0,0) :
                                   m_widget->mapToGlobal(m_displayRect.topLeft());
        int width = m_fullscreen ?
                        QApplication::desktop()->width() :
                        m_displayRect.width();
        int height = m_fullscreen ?
                               QApplication::desktop()->height() :
                               m_displayRect.height();

        if (m_metaData.hasVideo()) { // We need the source size to do aspect ratio scaling
            const qreal sourceRatio = m_metaData.width() / static_cast<float>(m_metaData.height());
            const qreal targetRatio = width / static_cast<float>(height);

            if (m_aspectRatioMode == Qt::KeepAspectRatio) {
                if (targetRatio < sourceRatio) {
                    // Need to make height smaller
                    const int newHeight = width / sourceRatio;
                    const int heightDiff = height - newHeight;
                    topLeft.ry() += heightDiff / 2;
                    height = newHeight;
                } else {
                    // Need to make width smaller
                    const int newWidth = sourceRatio * height;
                    const int widthDiff = width - newWidth;
                    topLeft.rx() += widthDiff / 2;
                    width = newWidth;
                }

            } else if (m_aspectRatioMode == Qt::KeepAspectRatioByExpanding) {
                if (targetRatio < sourceRatio) {
                    // Need to make width larger
                    const int newWidth = sourceRatio * height;
                    const int widthDiff = newWidth - width;
                    topLeft.rx() -= widthDiff / 2;
                    width = newWidth;
                } else {
                    // Need to make height larger
                    const int newHeight = width / sourceRatio;
                    const int heightDiff = newHeight - height;
                    topLeft.ry() -= heightDiff / 2;
                    height = newHeight;
                }
            }
        }

        if (m_window != 0) {
            const int position[2] = { topLeft.x(), topLeft.y() };
            const int size[2] = { width, height };
            if (screen_set_window_property_iv(m_window, SCREEN_PROPERTY_POSITION, position) != 0)
                perror("Setting video position failed");
            if (screen_set_window_property_iv(m_window, SCREEN_PROPERTY_SIZE, size) != 0)
                perror("Setting video size failed");
        }
    }
}
Example #13
0
/*
 * whether the mouse is on the window
 */
bool MainWindow::isMouseInsideWindow(QPoint p)
{
    int left=this->geometry().x();
    int right=left+this->width();
    int top=this->geometry().y();
    int bottom=top+this->height();
    if(p.rx()>=left && p.rx()<=right)
        if(p.ry()>=top && p.ry()<=bottom)
            return true;
    return false;
}
Example #14
0
int Field::count_neighbour_bombs(QPoint pt) {
    int neighbours = 0;

    for (int dy = -1; dy <= 1; ++dy)
        for (int dx = -1; dx <= 1; ++dx)
            if (cells[pt.ry() + dy][pt.rx() + dx] != nullptr  &&
                    !(cells[pt.ry() + dy][pt.rx() + dx]->empty())) {
                neighbours++;
            }

    return neighbours;
}
Example #15
0
void QAbstractKineticScrollerPrivate::checkMove(QMouseEvent *me, QPoint &delta)
{
    Q_Q(QAbstractKineticScroller);

    if (firstDrag && !moved && ((qAbs(delta.x()) > panningThreshold) || (qAbs(delta.y()) > panningThreshold))) {
        moved = true;
        // ignore the panning distance
        if (delta.x() > panningThreshold)
            delta.rx() -= panningThreshold;
        else if (delta.x() < -panningThreshold)
            delta.rx() += panningThreshold;
        else
            delta.setX(0);
        if (delta.y() > panningThreshold)
            delta.ry() -= panningThreshold;
        else if (delta.y() < -panningThreshold)
            delta.ry() += panningThreshold;
        else
            delta.setY(0);

        if (firstDrag) {
            int deltaXtoY = qAbs(ipos.x() - me->globalPos().x()) - qAbs(ipos.y() - me->globalPos().y());

            qKSDebug() << "First Drag with delta " << delta << ", greater than " << panningThreshold << " -- deltaXtoY: " << deltaXtoY;

            QPoint maxPos = q->maximumScrollPosition();
            bool canScrollX = (maxPos.x() > 0);
            bool canScrollY = (maxPos.y() > 0);

            if ((!canScrollX || !canScrollY) && (overshootPolicy == QAbstractKineticScroller::OvershootAlwaysOn))
                canScrollX = canScrollY = true;

            if (deltaXtoY < 0) {
                if (!canScrollY && (!canScrollX || (-deltaXtoY >= directionErrorMargin)))
                    moved = false;
            } else {
                if (!canScrollX && (!canScrollY || (deltaXtoY >= directionErrorMargin)))
                    moved = false;
            }
        }
        firstDrag = false;

        if (moved && (mode == QAbstractKineticScroller::AccelerationMode)) {

            if (!idleTimerId) {
                changeState(QAbstractKineticScroller::AutoScrolling);
                idleTimerId = startTimer(1000 / scrollsPerSecond);
            }
        }
    }
}
QRect GeneralManager::getPatchRect(QPoint patchCoordinate){
	int patchSizeMinusOverlap = parameter.patchSizeLower - parameter.OverlapSizeLower;
    QPoint topLeft;
    QPoint bottomRight;

    topLeft.setX(patchCoordinate.rx() * patchSizeMinusOverlap);
    topLeft.setY(patchCoordinate.ry() * patchSizeMinusOverlap);

    bottomRight.setX(parameter.patchSizeLower + topLeft.rx());
    bottomRight.setY(parameter.patchSizeLower + topLeft.ry());

    QRect returnRect(topLeft, bottomRight);
    return returnRect;
}
Example #17
0
void
OSDPreviewWidget::mouseMoveEvent( QMouseEvent *e )
{
    if( m_dragging && this == mouseGrabber() )
    {
        // Here we implement a "snap-to-grid" like positioning system for the preview widget

        const QRect screenRect  = QApplication::desktop()->screenGeometry( screen() );
        const uint  hcenter     = screenRect.width() / 2;
        const uint  eGlobalPosX = e->globalPos().x() - screenRect.left();
        const uint  snapZone    = screenRect.width() / 24;

        QPoint destination = e->globalPos() - m_dragOffset - screenRect.topLeft();
        int maxY = screenRect.height() - height() - MARGIN;
        if( destination.y() < MARGIN )
            destination.ry() = MARGIN;
        if( destination.y() > maxY )
            destination.ry() = maxY;

        if( eGlobalPosX < ( hcenter - snapZone ) )
        {
            setAlignment(Left);
            destination.rx() = MARGIN;
        }
        else if( eGlobalPosX > ( hcenter + snapZone ) )
        {
            setAlignment(Right);
            destination.rx() = screenRect.width() - MARGIN - width();
        }
        else {
            const uint eGlobalPosY = e->globalPos().y() - screenRect.top();
            const uint vcenter     = screenRect.height() / 2;

            destination.rx() = hcenter - width() / 2;

            if( eGlobalPosY >= ( vcenter - snapZone ) && eGlobalPosY <= ( vcenter + snapZone ) )
            {
                setAlignment(Center);
                destination.ry() = vcenter - height() / 2;
            }
            else
                setAlignment(Middle);
        }

        destination += screenRect.topLeft();

        move( destination );
    }
}
Example #18
0
void ToolTip::placeTip(const QPoint &pos, QWidget *w)
{
    QRect screen = Internal::screenGeometry(pos, w);
    QPoint p = pos;
    p += QPoint(2,
#ifdef Q_WS_WIN
                21
#else
                16
#endif
                );

    if (p.x() + m_tip->width() > screen.x() + screen.width())
        p.rx() -= 4 + m_tip->width();
    if (p.y() + m_tip->height() > screen.y() + screen.height())
        p.ry() -= 24 + m_tip->height();
    if (p.y() < screen.y())
        p.setY(screen.y());
    if (p.x() + m_tip->width() > screen.x() + screen.width())
        p.setX(screen.x() + screen.width() - m_tip->width());
    if (p.x() < screen.x())
        p.setX(screen.x());
    if (p.y() + m_tip->height() > screen.y() + screen.height())
        p.setY(screen.y() + screen.height() - m_tip->height());

    m_tip->move(p);
}
Example #19
0
QUML_BEGIN_NAMESPACE_GW

Popover::Popover(QWidget* parent, QPoint pos, Qt::Orientation orientation) :
        QWidget(parent), mLayout(new QVBoxLayout()) {
    setWindowFlags(Qt::Popup | Qt::Window | Qt::CustomizeWindowHint);
    setAttribute(Qt::WA_DeleteOnClose);

    mMouse = pos;
    mOrientation = orientation;

    // Slightly shift the origin for looks.
    if(mOrientation == Qt::Horizontal) {
        pos.ry() -= 26;
    } else {
        pos.rx() -= 26;
    }

    mPos = pos;

    setWindowOpacity(0.85);

    setLayout(mLayout);
    mLayout->setAlignment(Qt::AlignTop);

    setFocus();
}
Example #20
0
void LapsusOSD::reposition( QSize newSize )
{
	if( !newSize.isValid() ) newSize = size();

	QPoint newPos = _position;
	const QRect& screen = QApplication::desktop()->screenGeometry( _screen );

	// now to properly resize if put into one of the corners we interpret the position
	// depending on the quadrant
	int midH = screen.width()/2;
	int midV = screen.height()/2;

	if( newPos.x() > midH ) newPos.rx() -= newSize.width();
	if( newPos.y() > midV ) newPos.ry() -= newSize.height();

	newPos = fixupPosition( newPos );

	// correct for screen position
	newPos += screen.topLeft();

	// ensure we are painted before we move
	if( isVisible() ) paintEvent( 0 );

	// fancy X11 move+resize, reduces visual artifacts
	XMoveResizeWindow( x11Display(), winId(), newPos.x(), newPos.y(), newSize.width(), newSize.height() );
}
void GTUtilsMSAEditorSequenceArea::selectArea(HI::GUITestOpStatus &os, QPoint p1, QPoint p2)
{
    MSAEditorSequenceArea *msaEditArea = qobject_cast<MSAEditorSequenceArea*>(GTWidget::findWidget(os, "msa_editor_sequence_area", GTUtilsMdi::activeWindow(os)));
    GT_CHECK(msaEditArea != NULL, "MsaEditorSequenceArea not found");

    p1.rx() = p1.x()==-1 ? msaEditArea->getNumVisibleBases(true)-1 : p1.x();
    p2.rx() = p2.x()==-1 ? msaEditArea->getNumVisibleBases(true)-1 : p2.x();
    p1.ry() = p1.y()==-1 ? msaEditArea->getNumVisibleSequences(true)-1 : p1.y();
    p2.ry() = p2.y()==-1 ? msaEditArea->getNumVisibleSequences(true)-1 : p2.y();

    moveTo(os, p1);
    GTMouseDriver::press();
    GTMouseDriver::moveTo(convertCoordinates(os,p2));
    GTMouseDriver::release();
    GTGlobals::sleep(1000);
}
Example #22
0
QPoint QxtToolTipPrivate::calculatePos(int scr, const QPoint& eventPos) const
{
#ifdef Q_WS_MAC
    QRect screen = QApplication::desktop()->availableGeometry(scr);
#else
    QRect screen = QApplication::desktop()->screenGeometry(scr);
#endif

    QPoint p = eventPos;
    p += QPoint(2,
#ifdef Q_WS_WIN
                24
#else
                16
#endif
               );
    QSize s = sizeHint();
    if (p.x() + s.width() > screen.x() + screen.width())
        p.rx() -= 4 + s.width();
    if (p.y() + s.height() > screen.y() + screen.height())
        p.ry() -= 24 + s.height();
    if (p.y() < screen.y())
        p.setY(screen.y());
    if (p.x() + s.width() > screen.x() + screen.width())
        p.setX(screen.x() + screen.width() - s.width());
    if (p.x() < screen.x())
        p.setX(screen.x());
    if (p.y() + s.height() > screen.y() + screen.height())
        p.setY(screen.y() + screen.height() - s.height());
    return p;
}
Example #23
0
	QPoint FitRect (QPoint pos, const QSize& size, const QRect& geometry,
			FitFlags flags, const QPoint& shiftAdd)
	{
		int xDiff = std::max (0, pos.x () + size.width () - (geometry.width () + geometry.x ()));
		if (!xDiff)
			xDiff = std::min (0, pos.x () - geometry.x ());
		int yDiff = std::max (0, pos.y () + size.height () - (geometry.height () + geometry.y ()));
		if (!yDiff)
			yDiff = std::min (0, pos.y () - geometry.y ());

		if (flags & FitFlag::NoOverlap)
		{
			auto overlapFixer = [] (int& diff, int dim)
			{
				if (diff > 0)
					diff = dim > diff ? dim : diff;
			};

			if (QRect (pos - QPoint (xDiff, yDiff), size).contains (pos) && yDiff < size.height ())
				overlapFixer (yDiff, size.height ());
			if (QRect (pos - QPoint (xDiff, yDiff), size).contains (pos) && xDiff < size.width ())
				overlapFixer (xDiff, size.width ());
		}

		if (xDiff)
			pos.rx () -= xDiff + shiftAdd.x ();
		if (yDiff)
			pos.ry () -= yDiff + shiftAdd.y ();

		return pos;
	}
void AdmToolBoxSmoothDrag::sDelayedDragMoveEvent()
{
  // Make sure the timer is valid and we have a mouse position.
  if(NULL != _timer && _pointDragMoveEvent.isNull() == false)
  {
    // Stop the timer
    disconnect(_timer,SIGNAL(timeout()),this,SLOT(sDelayedDragMoveEvent()));
    _timer->stop();

    // Loop through the buttons of this widget and determine which button the
    // mouse is hovering over. The x value should be the widget location in this
    // QToolBox object
    int x = -1;
    foreach(QAbstractButton *btn, findChildren<QAbstractButton *>())
    {
      ++x;

      // Determine the button's region in relation to this QToolBox object
      QPoint mp = mapTo(this, btn->pos());
      QRect r(  mp.rx(),
                mp.ry(),
                btn->rect().width(),
                btn->rect().height()
      );

      // If the mouse position is hovering over this button, then select this
      // widget (x) and break out of the loop
      if(r.contains(_pointDragMoveEvent,false))
      {
        setCurrentWidget(widget(x));
        break;
      }
    }
Example #25
0
//Caculate the click location using one of the sixense controllers. Scale is not applied
QPoint ApplicationCompositor::getPalmClickLocation(const PalmData *palm) const {
    QPoint rv;
    auto canvasSize = qApp->getCanvasSize();
    if (qApp->isHMDMode()) {
        glm::vec2 polar = getPolarCoordinates(*palm);
        glm::vec2 point = sphericalToScreen(-polar);
        rv.rx() = point.x;
        rv.ry() = point.y;
    } else {
        MyAvatar* myAvatar = DependencyManager::get<AvatarManager>()->getMyAvatar();
        glm::dmat4 projection;
        qApp->getProjectionMatrix(&projection);
        glm::quat invOrientation = glm::inverse(myAvatar->getOrientation());
        glm::vec3 eyePos = myAvatar->getDefaultEyePosition();
        glm::vec3 tip = myAvatar->getLaserPointerTipPosition(palm);
        glm::vec3 tipPos = invOrientation * (tip - eyePos);

        glm::vec4 clipSpacePos = glm::vec4(projection * glm::dvec4(tipPos, 1.0));
        glm::vec3 ndcSpacePos;
        if (clipSpacePos.w != 0) {
            ndcSpacePos = glm::vec3(clipSpacePos) / clipSpacePos.w;
        }

        rv.setX(((ndcSpacePos.x + 1.0) / 2.0) * canvasSize.x);
        rv.setY((1.0 - ((ndcSpacePos.y + 1.0) / 2.0)) * canvasSize.y);
    }
    return rv;
}
Example #26
0
DS14::Coordinate replayDevice::toGameCo(QPoint programCo)
{
    DS14::Coordinate z;
    z.x = double((programCo.rx()-300))*4;
    z.y = double((300-programCo.ry()))*4;
    return z;
}
Example #27
0
void CanvasWidget::addSelectedPatch(QPoint point2D) {
    glm::vec3 realPoint = getOpenGLCoord(point2D);
    QPoint upperLeft;
    upperLeft.rx() = floor(float(realPoint.x) / float(SURFACE_STRIDE));
    upperLeft.ry() = floor(float(realPoint.y) / float(SURFACE_STRIDE));
    selectedPatches.push_back(upperLeft);
}
void QuotesTableView::onToolTip(QHelpEvent* e)
{
    if( !e ) return;

    // QT BUG: substract the header height (header row taken as row=0, 
    // so last row in the table will be mapped from point with row=-1)
    QPoint pt = mapFromGlobal(e->globalPos());
    pt.ry() -= height()/20;

    QModelIndex index = indexAt(pt);
    if( index.data().isNull() ) {
        QToolTip::hideText();
        return;
    }

    QString tipText;
    if( index.column() == 4 )
    {
        QToolTip::showText(e->globalPos(), 
            QString("The last request processed %1 msecs").arg(index.data().toInt()), this);
    }
    else if( index.column() == 5 )
    {
        QToolTip::showText(e->globalPos(), index.data().toString(), this);
    }
}
Example #29
0
/**
 * @brief execMenuAtWidget
 * @param menu
 * @param widget
 */
static void execMenuAtWidget(QMenu* menu, QWidget* widget)
{
  QPoint p;
  QRect screen = dream3dApp->desktop()->availableGeometry(widget);
  QSize sh = menu->sizeHint();
  QRect rect = widget->rect();
  if (widget->isRightToLeft())
  {
    if (widget->mapToGlobal(QPoint(0, rect.bottom())).y() + sh.height() <= screen.height())
    {
      p = widget->mapToGlobal(rect.bottomRight());
    }
    else
    {
      p = widget->mapToGlobal(rect.topRight() - QPoint(0, sh.height()));
    }
    p.rx() -= sh.width();
  }
  else
  {
    if (widget->mapToGlobal(QPoint(0, rect.bottom())).y() + sh.height() <= screen.height())
    {
      p = widget->mapToGlobal(rect.bottomLeft());
    }
    else
    {
      p = widget->mapToGlobal(rect.topLeft() - QPoint(0, sh.height()));
    }
  }
  p.rx() = qMax(screen.left(), qMin(p.x(), screen.right() - sh.width()));
  p.ry() += 1;

  menu->exec(p);
}
Example #30
0
QRect HexagonalRenderer::boundingRect(const QRect &rect) const
{
    const RenderParams p(map());

    QPoint topLeft = tileToScreenCoords(rect.topLeft()).toPoint();
    int width, height;

    if (p.staggerX) {
        width = rect.width() * p.columnWidth + p.sideOffsetX;
        height = rect.height() * (p.tileHeight + p.sideLengthY);

        if (rect.width() > 1) {
            height += p.rowHeight;
            if (p.doStaggerX(rect.x()))
                topLeft.ry() -= p.rowHeight;
        }
    } else {
        width = rect.width() * (p.tileWidth + p.sideLengthX);
        height = rect.height() * p.rowHeight + p.sideOffsetY;

        if (rect.height() > 1) {
            width += p.columnWidth;
            if (p.doStaggerY(rect.y()))
                topLeft.rx() -= p.columnWidth;
        }
    }

    return QRect(topLeft.x(), topLeft.y(), width, height);
}