void KoCreateShapeStrategy::paint(QPainter &painter, const KoViewConverter &converter)
{
if (m_outline.isEmpty())
KoShapeRubberSelectStrategy::paint(painter, converter);
else {
painter.save();
painter.setRenderHint(QPainter::Antialiasing, false);
QColor selectColor(Qt::blue); // TODO make configurable
selectColor.setAlphaF(0.5);
QBrush sb(selectColor, Qt::SolidPattern);
painter.setPen(QPen(sb, 0));
painter.setBrush(sb);
QRectF paintRect = converter.documentToView(selectRect());
qreal xscale = paintRect.width() / m_outlineBoundingRect.width();
qreal yscale = paintRect.height() / m_outlineBoundingRect.height();
QMatrix matrix;
matrix.translate(-m_outlineBoundingRect.left(), -m_outlineBoundingRect.top());
matrix.scale(xscale, yscale);
painter.translate(paintRect.left(), paintRect.top());
if (painter.hasClipping())
paintRect = paintRect.intersect(painter.clipRegion().boundingRect());
painter.setMatrix(matrix, true);
painter.drawPath(m_outline);
painter.restore();
}
}
void RS_OverlayBox::draw(RS_Painter* painter, RS_GraphicView* view, double& /*patternOffset*/) {
if (painter==NULL || view==NULL) {
return;
}
RS_Vector v1=view->toGui(getCorner1());
RS_Vector v2=view->toGui(getCorner2());
QRectF selectRect(
v1.x,
v1.y,
v2.x - v1.x,
v2.y - v1.y);
if (v1.y > v2.y) {
painter->setPen(QColor(50, 255, 50));
painter->fillRect(selectRect, RS_Color(9, 255, 9, 90));
}
else {
painter->setPen(QColor(50, 50, 255));
painter->fillRect(selectRect, RS_Color(9, 9, 255, 90));
}
painter->drawRect(v1, v2);
}
void ChatLine::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) {
Q_UNUSED(option);
Q_UNUSED(widget);
const QAbstractItemModel *model_ = model();
QModelIndex myIdx = model_->index(row(), 0);
Message::Type type = (Message::Type)myIdx.data(MessageModel::TypeRole).toInt();
UiStyle::MessageLabel label = (UiStyle::MessageLabel)myIdx.data(ChatLineModel::MsgLabelRole).toInt();
QTextCharFormat msgFmt = QtUi::style()->format(UiStyle::formatType(type), label);
if(msgFmt.hasProperty(QTextFormat::BackgroundBrush)) {
painter->fillRect(boundingRect(), msgFmt.background());
}
if(_selection & Selected) {
QTextCharFormat selFmt = QtUi::style()->format(UiStyle::formatType(type), label | UiStyle::Selected);
if(selFmt.hasProperty(QTextFormat::BackgroundBrush)) {
qreal left = item((ChatLineModel::ColumnType)(_selection & ItemMask))->pos().x();
QRectF selectRect(left, 0, width() - left, height());
painter->fillRect(selectRect, selFmt.background());
}
}
// draw chatitems
// the items draw themselves at the correct position
timestampItem()->paint(painter, option, widget);
senderItem()->paint(painter, option, widget);
contentsItem()->paint(painter, option, widget);
}
void CWndControl::RenderSelection(const QRect& windowRect, const QRect& parentRect)
{
const int select = s_selection.Find(this);
if (select != -1)
{
QRect selectRect(windowRect.topLeft() - QPoint(4, 4), windowRect.size() + QSize(8, 8));
m_render2D->SetOrigin(selectRect.topLeft());
if (selectRect.left() < parentRect.left()) selectRect.setLeft(parentRect.left());
if (selectRect.top() < parentRect.top()) selectRect.setTop(parentRect.top());
if (selectRect.right() > parentRect.right()) selectRect.setRight(parentRect.right());
if (selectRect.bottom() > parentRect.bottom()) selectRect.setBottom(parentRect.bottom());
m_render2D->SetViewport(selectRect);
const DWORD color1 = D3DCOLOR_ARGB(200, 128, 128, 255);
DWORD color2;
if (select == 0)
color2 = D3DCOLOR_ARGB(200, 255, 128, 128);
else
color2 = D3DCOLOR_ARGB(200, 106, 187, 217);
const QSize size = GetWindowRect(true).size();
m_render2D->RenderFillRect(QRect(0, 0, 5, 5), color1);
m_render2D->RenderFillRect(QRect(size.width() + 4, 0, 5, 5), color1);
m_render2D->RenderFillRect(QRect(size.width() + 4, size.height() + 4, 5, 5), color1);
m_render2D->RenderFillRect(QRect(0, size.height() + 4, 5, 5), color1);
m_render2D->RenderFillRect(QRect(4, 0, size.width() + 1, 5), color2);
m_render2D->RenderFillRect(QRect(0, 4, 5, size.height() + 1), color2);
m_render2D->RenderFillRect(QRect(size.width() + 4, 4, 5, size.height() + 1), color2);
m_render2D->RenderFillRect(QRect(4, size.height() + 4, size.width() + 1, 5), color2);
}
}
void SelectProjectScreen::openProjectGui()
{
Gui::label(Rect(centerPanel.x + PADDING,
centerPanel.y + PADDING, 300, 30),
"Select project to open:");
if(Gui::button(Rect(centerPanel.x + centerPanel.width - 100 - PADDING,
centerPanel.y + centerPanel.height - 25 - PADDING,
100, 25), "Open") == true)
{
openButtonClicked();
}
int yPad = 50;
Rect selectRect(centerPanel.x + PADDING, centerPanel.y + yPad, centerPanel.width - (PADDING * 2), centerPanel.height - (yPad * 2));
Gui::box(selectRect, "");
for(int i = 0; i < projects.size(); i++)
{
Rect itemRect(selectRect.x, selectRect.y + (20 * i), selectRect.width, 20);
if(projects.at(i) == selectedProject)
{
Gui::box(itemRect, projects.at(i));
}
else
{
Gui::label(itemRect, projects.at(i));
}
if(Input::getMouseButtonDown(0) == true && itemRect.contains(Input::getMousePosition()) == true)
{
selectedProject = projects.at(i);
}
}
}
QUndoCommand* KoCreateShapeStrategy::createCommand()
{
KoCreateShapesTool *parent = static_cast<KoCreateShapesTool*>(m_parent);
KoShapeFactory *factory = KoShapeRegistry::instance()->value(parent->shapeId());
if (! factory) {
kWarning(30006) << "Application requested a shape that is not registered" << parent->shapeId();
return 0;
}
const KoProperties *props = parent->shapeProperties();
KoShape *shape;
if (props)
shape = factory->createShapeAndInit(props, parent->m_canvas->shapeController()->dataCenterMap());
else
shape = factory->createDefaultShapeAndInit(parent->m_canvas->shapeController()->dataCenterMap());
if (shape->shapeId().isEmpty())
shape->setShapeId(factory->id());
QRectF rect = selectRect();
shape->setPosition(rect.topLeft());
QSizeF newSize = rect.size();
// if the user has dragged when creating the shape,
// resize the shape to the dragged size
if (newSize.width() > 1.0 && newSize.height() > 1.0)
shape->setSize(newSize);
QUndoCommand * cmd = parent->m_canvas->shapeController()->addShape(shape);
if (cmd) {
KoSelection *selection = parent->m_canvas->shapeManager()->selection();
selection->deselectAll();
selection->select(shape);
}
return cmd;
}
void ChatLine::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
{
Q_UNUSED(option);
Q_UNUSED(widget);
const QAbstractItemModel *model_ = model();
QModelIndex myIdx = model_->index(row(), 0);
// Draw a rect for the whole selection (all colums with seperators).
if (_selection & Selected) {
ChatItem *rightItem = item((MessageModel::ColumnType)((_selection & 0x0C)>>2));
qreal right = rightItem->pos().x() + rightItem->width();
qreal left = item((MessageModel::ColumnType)(_selection & 0x03))->pos().x();
QRectF selectRect(left, 0, right - left, height());
painter->fillRect(selectRect, QApplication::palette().highlight());
}
void QgsMapToolSelect::canvasReleaseEvent( QgsMapMouseEvent* e )
{
QgsVectorLayer* vlayer = QgsMapToolSelectUtils::getCurrentVectorLayer( mCanvas );
if ( !vlayer )
return;
QgsRubberBand rubberBand( mCanvas, Qgis::Polygon );
rubberBand.setFillColor( mFillColor );
rubberBand.setBorderColor( mBorderColour );
QRect selectRect( 0, 0, 0, 0 );
QgsMapToolSelectUtils::expandSelectRectangle( selectRect, vlayer, e->pos() );
QgsMapToolSelectUtils::setRubberBand( mCanvas, selectRect, &rubberBand );
QScopedPointer< QgsGeometry > selectGeom( rubberBand.asGeometry() );
QgsMapToolSelectUtils::selectSingleFeature( mCanvas, selectGeom.data(), e );
rubberBand.reset( Qgis::Polygon );
}
void QgsMapToolSelect::canvasReleaseEvent( QMouseEvent * e )
{
QgsVectorLayer* vlayer = QgsMapToolSelectUtils::getCurrentVectorLayer( mCanvas );
if( vlayer == NULL )
{
return;
}
QgsRubberBand rubberBand( mCanvas, true );
QRect selectRect( 0, 0, 0, 0 );
QgsMapToolSelectUtils::expandSelectRectangle( selectRect, vlayer, e->pos() );
QgsMapToolSelectUtils::setRubberBand( mCanvas, selectRect, &rubberBand );
QgsGeometry* selectGeom = rubberBand.asGeometry();
bool doDifference = e->modifiers() & Qt::ControlModifier ? true : false;
QgsMapToolSelectUtils::setSelectFeatures( mCanvas, selectGeom, false, doDifference, true );
delete selectGeom;
rubberBand.reset( true );
}
void OptMapToolDeleteLink::canvasReleaseEvent( QMouseEvent * e )
{
QgsVectorLayer* vlayer = QgsMapToolSelectUtils::getCurrentVectorLayer( mCanvas );
OptLineLayer* lineLayer = qobject_cast<OptLineLayer*>(vlayer);
if ( NULL == lineLayer ) {
QMessageBox::information(NULL, "", "only link layer can be edited");
return;
}
QgsRubberBand rubberBand( mCanvas, true );
QRect selectRect( 0, 0, 0, 0 );
QgsMapToolSelectUtils::expandSelectRectangle( selectRect, vlayer, e->pos() );
QgsMapToolSelectUtils::setRubberBand( mCanvas, selectRect, &rubberBand );
QgsGeometry* selectGeom = rubberBand.asGeometry();
bool doDifference = e->modifiers() & Qt::ControlModifier ? true : false;
QgsMapToolSelectUtils::setSelectFeatures( mCanvas, selectGeom, false, doDifference, true );
delete selectGeom;
rubberBand.reset( true );
deleteSelected( vlayer );
}
void CScreenShotView::mouseMoveEvent(QMouseEvent *event)
{
if(m_isLocked)
{
event->accept();
return;
}
if((event->buttons() & Qt::LeftButton) && m_isPressed)
{
m_selectRectItem->setVisible(true);
m_endPoint = event->pos();
QPointF startPoint = getPointToSelectedItem(m_startPoint);
QPointF endPoint = getPointToSelectedItem(event->pos());
QPointF maxPoint = getPointToSelectedItem(QPointF(this->geometry().width(),this->geometry().height()));
if(m_shotStatus == CSCREEN_SHOT_STATE_INITIALIZED)
{
if(endPoint.x() > maxPoint.x())
{
endPoint.setX(maxPoint.x());
}
if(endPoint.y() > maxPoint.y())
{
endPoint.setY(maxPoint.y());
}
if(endPoint.x() < 0)
{
endPoint.setX(0);
}
if(endPoint.y() < 0)
{
endPoint.setY(0);
}
// QRectF rect = getPositiveRect(startPoint,endPoint);
QRectF rect = CScreenshotUtil::convertLineFToRectF(QLineF(startPoint,endPoint));
m_selectRectItem->setSelectedRect(rect);
updateTooltipItem();
}
else if(m_shotStatus == CSCREEN_SHOT_STATE_SELECTED)
{
updateSelectRect(startPoint,endPoint);
}
else if(m_shotStatus == CSCREEN_SHOT_STATE_EDITED && m_currentRectItem)
{
// QRectF rect = getPositiveRect(m_startPoint,event->pos());
// QRectF rect = CScreenshotUtil::convertLineFToRectF(QLineF(m_startPoint,event->pos()));
// m_currentRectItem->setPainterRect(rect);
m_currentRectItem->setPainterLine(QLine(m_startPoint,event->pos()));
m_currentRectItem->setVisible(true);
}
}
if(m_shotStatus == CSCREEN_SHOT_STATE_INITIALIZED)
{
updatePreviewItem(event->pos());
if(!m_isPressed && !m_windowRectList.isEmpty())
{
QRect rect = getMouseOnWindowRect(event->globalPos());
QPoint startPoint = m_desktopScreen->geometry().topLeft();
QPointF topLeft = getPointToSelectedItem(rect.topLeft() - startPoint);
QPointF bottomRight = getPointToSelectedItem(rect.bottomRight() - startPoint);
QRectF selectRect(topLeft,bottomRight);
if(selectRect.isValid())
{
m_selectRectItem->setVisible(true);
m_selectRectItem->setSelectedRect(selectRect);
}
}
}
updateCursor(getPointToSelectedItem(event->pos()));
return QGraphicsView::mouseMoveEvent(event);
}
void QgsMapToolMoveFeature::cadCanvasReleaseEvent( QgsMapMouseEvent *e )
{
QgsVectorLayer *vlayer = currentVectorLayer();
if ( !vlayer || !vlayer->isEditable() )
{
delete mRubberBand;
mRubberBand = nullptr;
mSnapIndicator->setMatch( QgsPointLocator::Match() );
cadDockWidget()->clear();
notifyNotEditableLayer();
return;
}
if ( !mRubberBand )
{
//find first geometry under mouse cursor and store iterator to it
QgsPointXY layerCoords = toLayerCoordinates( vlayer, e->mapPoint() );
double searchRadius = QgsTolerance::vertexSearchRadius( mCanvas->currentLayer(), mCanvas->mapSettings() );
QgsRectangle selectRect( layerCoords.x() - searchRadius, layerCoords.y() - searchRadius,
layerCoords.x() + searchRadius, layerCoords.y() + searchRadius );
if ( vlayer->selectedFeatureCount() == 0 )
{
QgsFeatureIterator fit = vlayer->getFeatures( QgsFeatureRequest().setFilterRect( selectRect ).setNoAttributes() );
//find the closest feature
QgsGeometry pointGeometry = QgsGeometry::fromPointXY( layerCoords );
if ( pointGeometry.isNull() )
{
cadDockWidget()->clear();
return;
}
double minDistance = std::numeric_limits<double>::max();
QgsFeature cf;
QgsFeature f;
while ( fit.nextFeature( f ) )
{
if ( f.hasGeometry() )
{
double currentDistance = pointGeometry.distance( f.geometry() );
if ( currentDistance < minDistance )
{
minDistance = currentDistance;
cf = f;
}
}
}
if ( minDistance == std::numeric_limits<double>::max() )
{
cadDockWidget()->clear();
return;
}
mMovedFeatures.clear();
mMovedFeatures << cf.id(); //todo: take the closest feature, not the first one...
mRubberBand = createRubberBand( vlayer->geometryType() );
mRubberBand->setToGeometry( cf.geometry(), vlayer );
}
else
{
mMovedFeatures = vlayer->selectedFeatureIds();
mRubberBand = createRubberBand( vlayer->geometryType() );
QgsFeature feat;
QgsFeatureIterator it = vlayer->getSelectedFeatures( QgsFeatureRequest().setNoAttributes() );
bool allFeaturesInView = true;
QgsRectangle viewRect = mCanvas->mapSettings().mapToLayerCoordinates( vlayer, mCanvas->extent() );
while ( it.nextFeature( feat ) )
{
mRubberBand->addGeometry( feat.geometry(), vlayer );
if ( allFeaturesInView && !viewRect.intersects( feat.geometry().boundingBox() ) )
allFeaturesInView = false;
}
if ( !allFeaturesInView )
{
// for extra safety to make sure we are not modifying geometries by accident
int res = QMessageBox::warning( mCanvas, tr( "Move features" ),
tr( "Some of the selected features are outside of the current map view. Would you still like to continue?" ),
QMessageBox::Yes | QMessageBox::No );
if ( res != QMessageBox::Yes )
{
mMovedFeatures.clear();
delete mRubberBand;
mRubberBand = nullptr;
mSnapIndicator->setMatch( QgsPointLocator::Match() );
return;
}
}
}
mStartPointMapCoords = e->mapPoint();
mRubberBand->show();
}
else
{
// copy and move mode
if ( e->button() != Qt::LeftButton )
{
cadDockWidget()->clear();
delete mRubberBand;
mRubberBand = nullptr;
mSnapIndicator->setMatch( QgsPointLocator::Match() );
return;
}
QgsPointXY startPointLayerCoords = toLayerCoordinates( ( QgsMapLayer * )vlayer, mStartPointMapCoords );
QgsPointXY stopPointLayerCoords = toLayerCoordinates( ( QgsMapLayer * )vlayer, e->mapPoint() );
double dx = stopPointLayerCoords.x() - startPointLayerCoords.x();
double dy = stopPointLayerCoords.y() - startPointLayerCoords.y();
vlayer->beginEditCommand( mMode == Move ? tr( "Feature moved" ) : tr( "Feature copied and moved" ) );
switch ( mMode )
{
case Move:
Q_FOREACH ( QgsFeatureId id, mMovedFeatures )
{
vlayer->translateFeature( id, dx, dy );
}
delete mRubberBand;
mRubberBand = nullptr;
mSnapIndicator->setMatch( QgsPointLocator::Match() );
cadDockWidget()->clear();
break;
case CopyMove:
QgsFeatureRequest request;
request.setFilterFids( mMovedFeatures );
QString *errorMsg = new QString();
if ( !QgisApp::instance()->vectorLayerTools()->copyMoveFeatures( vlayer, request, dx, dy, errorMsg ) )
{
emit messageEmitted( *errorMsg, Qgis::Critical );
delete mRubberBand;
mRubberBand = nullptr;
mSnapIndicator->setMatch( QgsPointLocator::Match() );
}
break;
}
vlayer->endEditCommand();
vlayer->triggerRepaint();
}
void QgsMapToolRotateFeature::canvasReleaseEvent( QgsMapMouseEvent *e )
{
if ( !mCanvas )
{
return;
}
QgsVectorLayer *vlayer = currentVectorLayer();
if ( !vlayer )
{
deleteRotationWidget();
deleteRubberband();
notifyNotVectorLayer();
return;
}
if ( e->button() == Qt::RightButton )
{
cancel();
return;
}
// place anchor point on CTRL + click
if ( e->modifiers() & Qt::ControlModifier )
{
if ( !mAnchorPoint )
{
return;
}
mAnchorPoint->setCenter( toMapCoordinates( e->pos() ) );
mStartPointMapCoords = toMapCoordinates( e->pos() );
mStPoint = e->pos();
return;
}
deleteRotationWidget();
// Initialize rotation if not yet active
if ( !mRotationActive )
{
mRotation = 0;
mRotationOffset = 0;
deleteRubberband();
mInitialPos = e->pos();
if ( !vlayer->isEditable() )
{
notifyNotEditableLayer();
return;
}
QgsPointXY layerCoords = toLayerCoordinates( vlayer, e->pos() );
double searchRadius = QgsTolerance::vertexSearchRadius( mCanvas->currentLayer(), mCanvas->mapSettings() );
QgsRectangle selectRect( layerCoords.x() - searchRadius, layerCoords.y() - searchRadius,
layerCoords.x() + searchRadius, layerCoords.y() + searchRadius );
if ( vlayer->selectedFeatureCount() == 0 )
{
QgsFeatureIterator fit = vlayer->getFeatures( QgsFeatureRequest().setFilterRect( selectRect ).setNoAttributes() );
//find the closest feature
QgsGeometry pointGeometry = QgsGeometry::fromPointXY( layerCoords );
if ( pointGeometry.isNull() )
{
return;
}
double minDistance = std::numeric_limits<double>::max();
QgsFeature cf;
QgsFeature f;
while ( fit.nextFeature( f ) )
{
if ( f.hasGeometry() )
{
double currentDistance = pointGeometry.distance( f.geometry() );
if ( currentDistance < minDistance )
{
minDistance = currentDistance;
cf = f;
}
}
}
if ( minDistance == std::numeric_limits<double>::max() )
{
emit messageEmitted( tr( "Could not find a nearby feature in the current layer." ) );
return;
}
QgsRectangle bound = cf.geometry().boundingBox();
mStartPointMapCoords = toMapCoordinates( vlayer, bound.center() );
if ( !mAnchorPoint )
{
mAnchorPoint = qgis::make_unique<QgsVertexMarker>( mCanvas );
}
mAnchorPoint->setIconType( QgsVertexMarker::ICON_CROSS );
mAnchorPoint->setCenter( mStartPointMapCoords );
mStPoint = toCanvasCoordinates( mStartPointMapCoords );
mRotatedFeatures.clear();
mRotatedFeatures << cf.id(); //todo: take the closest feature, not the first one...
mRubberBand = createRubberBand( vlayer->geometryType() );
mRubberBand->setToGeometry( cf.geometry(), vlayer );
}
else
{
mRotatedFeatures = vlayer->selectedFeatureIds();
mRubberBand = createRubberBand( vlayer->geometryType() );
QgsFeature feat;
QgsFeatureIterator it = vlayer->getSelectedFeatures();
while ( it.nextFeature( feat ) )
{
mRubberBand->addGeometry( feat.geometry(), vlayer );
}
}
mRubberBand->show();
double XDistance = mInitialPos.x() - mAnchorPoint->x();
double YDistance = mInitialPos.y() - mAnchorPoint->y();
mRotationOffset = std::atan2( YDistance, XDistance ) * ( 180 / M_PI );
createRotationWidget();
if ( e->modifiers() & Qt::ShiftModifier )
{
if ( mRotationWidget )
{
mRotationWidget->setMagnet( 45 );
}
}
mRotationActive = true;
return;
}
applyRotation( mRotation );
}
void QgsMapToolRotateFeature::canvasPressEvent( QMouseEvent * e )
{
mRotation = 0;
if ( mCtrl )
{
return;
}
delete mRubberBand;
mRubberBand = 0;
mInitialPos = e->pos();
QgsVectorLayer* vlayer = currentVectorLayer();
if ( !vlayer )
{
notifyNotVectorLayer();
return;
}
if ( !vlayer->isEditable() )
{
notifyNotEditableLayer();
return;
}
QgsPoint layerCoords = toLayerCoordinates( vlayer, e->pos() );
double searchRadius = QgsTolerance::vertexSearchRadius( mCanvas->currentLayer(), mCanvas->mapSettings() );
QgsRectangle selectRect( layerCoords.x() - searchRadius, layerCoords.y() - searchRadius,
layerCoords.x() + searchRadius, layerCoords.y() + searchRadius );
if ( vlayer->selectedFeatureCount() == 0 )
{
QgsFeatureIterator fit = vlayer->getFeatures( QgsFeatureRequest().setFilterRect( selectRect ).setSubsetOfAttributes( QgsAttributeList() ) );
//find the closest feature
QgsGeometry* pointGeometry = QgsGeometry::fromPoint( layerCoords );
if ( !pointGeometry )
{
return;
}
double minDistance = std::numeric_limits<double>::max();
QgsFeature cf;
QgsFeature f;
while ( fit.nextFeature( f ) )
{
if ( f.geometry() )
{
double currentDistance = pointGeometry->distance( *f.geometry() );
if ( currentDistance < minDistance )
{
minDistance = currentDistance;
cf = f;
}
}
}
delete pointGeometry;
if ( minDistance == std::numeric_limits<double>::max() )
{
return;
}
QgsRectangle bound = cf.geometry()->boundingBox();
mStartPointMapCoords = toMapCoordinates( vlayer, bound.center() );
if ( !mAnchorPoint )
{
mAnchorPoint = new QgsVertexMarker( mCanvas );
}
mAnchorPoint->setIconType( QgsVertexMarker::ICON_CROSS );
mAnchorPoint->setCenter( mStartPointMapCoords );
mStPoint = toCanvasCoordinates( mStartPointMapCoords );
mRotatedFeatures.clear();
mRotatedFeatures << cf.id(); //todo: take the closest feature, not the first one...
mRubberBand = createRubberBand( vlayer->geometryType() );
mRubberBand->setToGeometry( cf.geometry(), vlayer );
}
else
{
mRotatedFeatures = vlayer->selectedFeaturesIds();
mRubberBand = createRubberBand( vlayer->geometryType() );
QgsFeature feat;
QgsFeatureIterator it = vlayer->selectedFeaturesIterator();
while ( it.nextFeature( feat ) )
{
mRubberBand->addGeometry( feat.geometry(), vlayer );
}
}
mRubberBand->setColor( QColor( 255, 0, 0, 65 ) );
mRubberBand->setWidth( 2 );
mRubberBand->show();
double XDistance = mInitialPos.x() - mAnchorPoint->x();
double YDistance = mInitialPos.y() - mAnchorPoint->y() ;
mRotationOffset = atan2( YDistance, XDistance ) * ( 180 / PI );
}
void KoCreateShapeStrategy::finishInteraction(Qt::KeyboardModifiers modifiers)
{
Q_UNUSED(modifiers);
m_canvas->updateCanvas(selectRect());
}
void QgsMapToolMoveFeature::canvasPressEvent( QgsMapMouseEvent* e )
{
delete mRubberBand;
mRubberBand = nullptr;
QgsVectorLayer* vlayer = currentVectorLayer();
if ( !vlayer )
{
notifyNotVectorLayer();
return;
}
if ( !vlayer->isEditable() )
{
notifyNotEditableLayer();
return;
}
//find first geometry under mouse cursor and store iterator to it
QgsPoint layerCoords = toLayerCoordinates( vlayer, e->pos() );
QSettings settings;
double searchRadius = QgsTolerance::vertexSearchRadius( mCanvas->currentLayer(), mCanvas->mapSettings() );
QgsRectangle selectRect( layerCoords.x() - searchRadius, layerCoords.y() - searchRadius,
layerCoords.x() + searchRadius, layerCoords.y() + searchRadius );
if ( vlayer->selectedFeatureCount() == 0 )
{
QgsFeatureIterator fit = vlayer->getFeatures( QgsFeatureRequest().setFilterRect( selectRect ).setSubsetOfAttributes( QgsAttributeList() ) );
//find the closest feature
QgsGeometry* pointGeometry = QgsGeometry::fromPoint( layerCoords );
if ( !pointGeometry )
{
return;
}
double minDistance = std::numeric_limits<double>::max();
QgsFeature cf;
QgsFeature f;
while ( fit.nextFeature( f ) )
{
if ( f.constGeometry() )
{
double currentDistance = pointGeometry->distance( *f.constGeometry() );
if ( currentDistance < minDistance )
{
minDistance = currentDistance;
cf = f;
}
}
}
delete pointGeometry;
if ( minDistance == std::numeric_limits<double>::max() )
{
return;
}
mMovedFeatures.clear();
mMovedFeatures << cf.id(); //todo: take the closest feature, not the first one...
mRubberBand = createRubberBand( vlayer->geometryType() );
mRubberBand->setToGeometry( cf.constGeometry(), vlayer );
}
else
{
mMovedFeatures = vlayer->selectedFeaturesIds();
mRubberBand = createRubberBand( vlayer->geometryType() );
QgsFeature feat;
QgsFeatureIterator it = vlayer->selectedFeaturesIterator( QgsFeatureRequest().setSubsetOfAttributes( QgsAttributeList() ) );
while ( it.nextFeature( feat ) )
{
mRubberBand->addGeometry( feat.constGeometry(), vlayer );
}
}
mStartPointMapCoords = toMapCoordinates( e->pos() );
mRubberBand->setColor( QColor( 255, 0, 0, 65 ) );
mRubberBand->setWidth( 2 );
mRubberBand->show();
}
void KoCreateShapeStrategy::handleMouseMove(const QPointF &point, Qt::KeyboardModifiers modifiers)
{
KoShapeRubberSelectStrategy::handleMouseMove(point, modifiers);
if (! m_outline.isEmpty())
m_canvas->updateCanvas(selectRect());
}
QgsGeometry* QgsMapToolDeletePart::partUnderPoint( QPoint point, QgsFeatureId& fid, int& partNum )
{
QgsFeature f;
QgsGeometry* geomPart = new QgsGeometry();
switch ( vlayer->geometryType() )
{
case QGis::Point:
case QGis::Line:
{
QgsPointLocator::Match match = mCanvas->snappingUtils()->snapToCurrentLayer( point, QgsPointLocator::Vertex | QgsPointLocator::Edge );
if ( !match.isValid() )
return geomPart;
int snapVertex = match.vertexIndex();
vlayer->getFeatures( QgsFeatureRequest().setFilterFid( match.featureId() ) ).nextFeature( f );
const QgsGeometry* g = f.constGeometry();
if ( !g->isMultipart() )
{
fid = match.featureId();
delete geomPart;
return QgsGeometry::fromPoint( match.point() );
}
if ( g->wkbType() == QGis::WKBMultiPoint || g->wkbType() == QGis::WKBMultiPoint25D )
{
fid = match.featureId();
partNum = snapVertex;
delete geomPart;
return QgsGeometry::fromPoint( match.point() );
}
if ( g->wkbType() == QGis::WKBMultiLineString || g->wkbType() == QGis::WKBMultiLineString25D )
{
QgsMultiPolyline mline = g->asMultiPolyline();
for ( int part = 0; part < mline.count(); part++ )
{
if ( snapVertex < mline[part].count() )
{
fid = match.featureId();
partNum = part;
delete geomPart;
return QgsGeometry::fromPolyline( mline[part] );
}
snapVertex -= mline[part].count();
}
}
break;
}
case QGis::Polygon:
{
QgsPoint layerCoords = toLayerCoordinates( vlayer, point );
double searchRadius = QgsTolerance::vertexSearchRadius( mCanvas->currentLayer(), mCanvas->mapSettings() );
QgsRectangle selectRect( layerCoords.x() - searchRadius, layerCoords.y() - searchRadius,
layerCoords.x() + searchRadius, layerCoords.y() + searchRadius );
QgsFeatureIterator fit = vlayer->getFeatures( QgsFeatureRequest().setFilterRect( selectRect ) );
fit.nextFeature( f );
const QgsGeometry* g = f.constGeometry();
if ( !g )
return geomPart;
if ( !g->isMultipart() )
{
fid = f.id();
return geomPart;
}
QgsMultiPolygon mpolygon = g->asMultiPolygon();
for ( int part = 0; part < mpolygon.count(); part++ ) // go through the polygons
{
const QgsPolygon& polygon = mpolygon[part];
QgsGeometry* partGeo = QgsGeometry::fromPolygon( polygon );
if ( partGeo->contains( &layerCoords ) )
{
fid = f.id();
partNum = part;
delete geomPart;
return partGeo;
}
delete partGeo;
}
break;
}
default:
{
break;
}
}
return geomPart;
}
void CDTMapToolSelectTrainingSamples::canvasReleaseEvent(QgsMapMouseEvent *e)
{
if ( e->button() == Qt::LeftButton )
{
if ( mDragging )
{
mCanvas->panActionEnd( e->pos() );
mDragging = false;
}
else // add pan to mouse cursor
{
// transform the mouse pos to map coordinates
QgsPoint center = mCanvas->getCoordinateTransform()->toMapPoint( e->x(), e->y() );
mCanvas->setExtent( QgsRectangle( center, center ) );
mCanvas->refresh();
}
}
else if (e->button()==Qt::RightButton)
{
QgsVectorLayer* vlayer = NULL;
if ( !mapCanvas->currentLayer()
|| ( vlayer = qobject_cast<QgsVectorLayer *>( mapCanvas->currentLayer() ) ) == NULL )
return;
QRect selectRect( 0, 0, 0, 0 );
int boxSize = 1;
selectRect.setLeft ( e->pos().x() - boxSize );
selectRect.setRight ( e->pos().x() + boxSize );
selectRect.setTop ( e->pos().y() - boxSize );
selectRect.setBottom( e->pos().y() + boxSize );
const QgsMapToPixel* transform = mapCanvas->getCoordinateTransform();
QgsPoint ll = transform->toMapCoordinates( selectRect.left(), selectRect.bottom() );
QgsPoint ur = transform->toMapCoordinates( selectRect.right(), selectRect.top() );
QgsPolyline points;
points.push_back(ll);
points.push_back(QgsPoint( ur.x(), ll.y() ));
points.push_back(ur);
points.push_back(QgsPoint( ll.x(), ur.y() ));
QgsPolygon polygon;
polygon.push_back(points);
QgsGeometry selectGeom = *(QgsGeometry::fromPolygon(polygon) );
if ( mapCanvas->mapSettings().hasCrsTransformEnabled() )
{
QgsCoordinateTransform ct( mapCanvas->mapSettings().destinationCrs(), vlayer->crs() );
selectGeom.transform( ct );
}
QgsFeatureIterator fit = vlayer->getFeatures( QgsFeatureRequest().setFilterRect( selectGeom.boundingBox() ).setFlags( QgsFeatureRequest::ExactIntersect ) );
QgsFeature f;
qint64 closestFeatureId = 0;
bool foundSingleFeature = false;
double closestFeatureDist = std::numeric_limits<double>::max();
while ( fit.nextFeature( f ) )
{
QgsGeometry* g = f.geometry();
if ( !selectGeom.intersects( g ) )
continue;
foundSingleFeature = true;
double distance = g->distance( selectGeom );
if ( distance <= closestFeatureDist )
{
closestFeatureDist = distance;
closestFeatureId = f.attribute("GridCode").toInt();
}
}
if ( foundSingleFeature )
addSingleSample( closestFeatureId );
}
}
QgsGeometry* QgsMapToolDeletePart::partUnderPoint( QPoint point, int& fid, int& partNum )
{
QgsFeature f;
QgsGeometry* geomPart = new QgsGeometry();
switch ( vlayer->geometryType() )
{
case QGis::Point:
case QGis::Line:
{
if ( mSnapper.snapToCurrentLayer( point, mRecentSnappingResults, QgsSnapper::SnapToVertexAndSegment ) == 0 )
{
if ( mRecentSnappingResults.length() > 0 )
{
QgsSnappingResult sr = mRecentSnappingResults.first();
int snapVertex = sr.snappedVertexNr;
if ( snapVertex == -1 )
snapVertex = sr.beforeVertexNr;
vlayer->getFeatures( QgsFeatureRequest().setFilterFid( sr.snappedAtGeometry ) ).nextFeature( f );
QgsGeometry* g = f.geometry();
if ( !g->isMultipart() )
return geomPart;
if ( g->wkbType() == QGis::WKBMultiPoint || g->wkbType() == QGis::WKBMultiPoint25D )
{
fid = sr.snappedAtGeometry;
partNum = snapVertex;
return QgsGeometry::fromPoint( sr.snappedVertex );
}
if ( g->wkbType() == QGis::WKBMultiLineString || g->wkbType() == QGis::WKBMultiLineString25D )
{
QgsMultiPolyline mline = g->asMultiPolyline();
for ( int part = 0; part < mline.count(); part++ )
{
if ( snapVertex < mline[part].count() )
{
fid = sr.snappedAtGeometry;
partNum = part;
return QgsGeometry::fromPolyline( mline[part] );
}
snapVertex -= mline[part].count();
}
}
}
}
break;
}
case QGis::Polygon:
{
QgsPoint layerCoords = toLayerCoordinates( vlayer, point );
double searchRadius = QgsTolerance::vertexSearchRadius( mCanvas->currentLayer(), mCanvas->mapSettings() );
QgsRectangle selectRect( layerCoords.x() - searchRadius, layerCoords.y() - searchRadius,
layerCoords.x() + searchRadius, layerCoords.y() + searchRadius );
QgsFeatureIterator fit = vlayer->getFeatures( QgsFeatureRequest().setFilterRect( selectRect ) );
fit.nextFeature( f );
QgsGeometry* g = f.geometry();
if ( !g )
return geomPart;
if ( !g->isMultipart() )
return geomPart;
QgsMultiPolygon mpolygon = g->asMultiPolygon();
for ( int part = 0; part < mpolygon.count(); part++ ) // go through the polygons
{
const QgsPolygon& polygon = mpolygon[part];
QgsGeometry* partGeo = QgsGeometry::fromPolygon( polygon );
if ( partGeo->contains( &layerCoords ) )
{
fid = f.id();
partNum = part;
return partGeo;
}
}
break;
}
default:
{
break;
}
}
return geomPart;
}