void KarbonView::dropEvent( QDropEvent *e )
{
debugView("KarbonView::dropEvent()");
//Accepts QColor - from Color Manager's KColorPatch
QColor color = KColorMimeData::fromMimeData( e->mimeData() );
if ( color.isValid() )
{
KoSelection * selection = d->canvas->shapeManager()->selection();
if( ! selection )
return;
if( ! part() )
return;
if( d->canvas->resourceProvider()->intResource( Karbon::ActiveStyle ) == Karbon::Foreground )
{
QList<KoShapeBorderModel*> borders;
QList<KoShape*> selectedShapes = selection->selectedShapes();
foreach( KoShape * shape, selectedShapes )
{
KoLineBorder * border = dynamic_cast<KoLineBorder*>( shape->border() );
KoLineBorder * newBorder = 0;
if( border )
{
newBorder = new KoLineBorder( *border );
newBorder->setColor( color );
}
else
{
newBorder = new KoLineBorder( 1.0, color );
}
borders.append( newBorder );
}
void KarbonCalligraphyTool::updateSelectedPath()
{
KoPathShape *oldSelectedPath = m_selectedPath; // save old value
KoSelection *selection = canvas()->shapeManager()->selection();
// null pointer if it the selection isn't a KoPathShape
// or if the selection is empty
m_selectedPath =
dynamic_cast<KoPathShape *>(selection->firstSelectedShape());
// or if it's a KoPathShape but with no or more than one subpaths
if (m_selectedPath && m_selectedPath->subpathCount() != 1) {
m_selectedPath = 0;
}
// or if there ora none or more than 1 shapes selected
if (selection->count() != 1) {
m_selectedPath = 0;
}
// emit signal it there wasn't a selected path and now there is
// or the other way around
if ((m_selectedPath != 0) != (oldSelectedPath != 0)) {
emit pathSelectedChanged(m_selectedPath != 0);
}
}
void KoCreatePathTool::addPathShape(KoPathShape *pathShape)
{
Q_D(KoCreatePathTool);
KoPathShape *startShape = 0;
KoPathShape *endShape = 0;
pathShape->normalize();
// check if existing start/end points are still valid
d->existingStartPoint.validate(canvas());
d->existingEndPoint.validate(canvas());
pathShape->setStroke(createStroke());
if (d->connectPaths(pathShape, d->existingStartPoint, d->existingEndPoint)) {
if (d->existingStartPoint.isValid())
startShape = d->existingStartPoint.path;
if (d->existingEndPoint.isValid() && d->existingEndPoint != d->existingStartPoint)
endShape = d->existingEndPoint.path;
}
KUndo2Command *cmd = canvas()->shapeController()->addShape(pathShape);
if (cmd) {
KoSelection *selection = canvas()->shapeManager()->selection();
selection->deselectAll();
selection->select(pathShape);
if (startShape)
canvas()->shapeController()->removeShape(startShape, cmd);
if (endShape && startShape != endShape)
canvas()->shapeController()->removeShape(endShape, cmd);
canvas()->addCommand(cmd);
} else {
canvas()->updateCanvas(pathShape->boundingRect());
delete pathShape;
}
}
void KPrViewModeNotes::updateActivePage( KoPAPageBase *page )
{
if ( m_view->activePage() != page ) {
m_view->setActivePage( page );
}
KPrPage *prPage = dynamic_cast<KPrPage *>( page );
if ( !prPage ) return;
KPrNotes *notes = prPage->pageNotes();
notes->updatePageThumbnail();
KoShapeLayer* layer = dynamic_cast<KoShapeLayer*>( notes->childShapes().last() );
KoPageLayout &layout = notes->pageLayout();
QSize size(layout.width, layout.height);
m_view->horizontalRuler()->setRulerLength(layout.width);
m_view->verticalRuler()->setRulerLength(layout.height);
m_view->horizontalRuler()->setActiveRange(layout.left, layout.width - layout.right);
m_view->verticalRuler()->setActiveRange(layout.top, layout.height - layout.bottom);
m_view->zoomController()->setPageSize(size);
m_view->zoomController()->setDocumentSize(size);
m_canvas->update();
m_canvas->shapeManager()->setShapes( layer->childShapes() );
m_canvas->masterShapeManager()->setShapes(QList<KoShape*>());
KoSelection *selection = m_canvas->shapeManager()->selection();
selection->select(notes->textShape());
selection->setActiveLayer( layer );
QString tool = KoToolManager::instance()->preferredToolForSelection(selection->selectedShapes());
KoToolManager::instance()->switchToolRequested(tool);
}
void RoundCornersPlugin::slotRoundCorners()
{
KoCanvasController* canvasController = KoToolManager::instance()->activeCanvasController();
KoSelection *selection = canvasController->canvas()->shapeManager()->selection();
KoShape * shape = selection->firstSelectedShape();
if (! shape)
return;
// check if we have a path based shape
KoPathShape * path = dynamic_cast<KoPathShape*>(shape);
if (! path)
return;
m_roundCornersDlg->setUnit(canvasController->canvas()->unit());
if (QDialog::Rejected == m_roundCornersDlg->exec())
return;
KUndo2Command * cmd = new KUndo2Command(kundo2_i18n("Round Corners"));
// convert to path before if we have a parametric shape
KoParameterShape * ps = dynamic_cast<KoParameterShape*>(shape);
if (ps && ps->isParametricShape())
new KoParameterToPathCommand(ps, cmd);
new RoundCornersCommand(path, m_roundCornersDlg->radius(), cmd);
canvasController->canvas()->addCommand(cmd);
}
KUndo2Command* KoCreateShapeStrategy::createCommand()
{
Q_D(KoShapeRubberSelectStrategy);
KoCreateShapesTool *parent = static_cast<KoCreateShapesTool*>(d_ptr->tool);
KoShapeFactoryBase *factory = KoShapeRegistry::instance()->value(parent->shapeId());
if (! factory) {
warnFlake << "Application requested a shape that is not registered" << parent->shapeId();
return 0;
}
const KoProperties *props = parent->shapeProperties();
KoShape *shape;
if (props)
shape = factory->createShape(props, parent->canvas()->shapeController()->resourceManager());
else
shape = factory->createDefaultShape(parent->canvas()->shapeController()->resourceManager());
if (shape->shapeId().isEmpty())
shape->setShapeId(factory->id());
QRectF rect = d->selectedRect();
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);
KUndo2Command * cmd = parent->canvas()->shapeController()->addShape(shape);
if (cmd) {
KoSelection *selection = parent->canvas()->shapeManager()->selection();
selection->deselectAll();
selection->select(shape);
}
return cmd;
}
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 WhirlPinchPlugin::slotWhirlPinch()
{
KoCanvasController* canvasController = KoToolManager::instance()->activeCanvasController();
KoSelection *selection = canvasController->canvas()->shapeManager()->selection();
KoShape * shape = selection->firstSelectedShape();
if (! shape)
return;
// check if we have a path based shape
KoPathShape * path = dynamic_cast<KoPathShape*>(shape);
if (! path)
return;
// check if it is no parametric shape
KoParameterShape * ps = dynamic_cast<KoParameterShape*>(shape);
if (ps && ps->isParametricShape())
return;
m_whirlPinchDlg->setUnit(canvasController->canvas()->unit());
if (QDialog::Rejected == m_whirlPinchDlg->exec())
return;
canvasController->canvas()->addCommand(
new KarbonWhirlPinchCommand(path, m_whirlPinchDlg->angle(), m_whirlPinchDlg->pinch(), m_whirlPinchDlg->radius()));
}
void StrokeDocker::selectionChanged()
{
KoCanvasController* canvasController = KoToolManager::instance()->activeCanvasController();
KoSelection *selection = canvasController->canvas()->shapeManager()->selection();
KoShape * shape = selection->firstSelectedShape();
if( shape )
setStroke( shape->border() );
}
void KarbonCalligraphyTool::deactivate()
{
if (m_lastShape && canvas()->shapeManager()->shapes().contains(m_lastShape)) {
KoSelection *selection = canvas()->shapeManager()->selection();
selection->deselectAll();
selection->select(m_lastShape);
}
}
void KPrView::createAnimation()
{
static int animationcount = 0;
KoSelection * selection = kopaCanvas()->shapeManager()->selection();
QList<KoShape*> selectedShapes = selection->selectedShapes();
foreach( KoShape * shape, selectedShapes )
{
Q_UNUSED(shape);
/*KPrShapeAnimationOld * animation = new KPrAnimationMoveAppear( shape, animationcount );
KPrDocument * doc = static_cast<KPrDocument *>( kopaDocument() );
KPrAnimationCreateCommand * command = new KPrAnimationCreateCommand( doc, animation );
kopaCanvas()->addCommand( command );*/
}
bool KisNodeManager::Private::activateNodeImpl(KisNodeSP node)
{
Q_ASSERT(view);
Q_ASSERT(view->canvasBase());
Q_ASSERT(view->canvasBase()->globalShapeManager());
Q_ASSERT(imageView);
if (node && node == q->activeNode()) {
return false;
}
// Set the selection on the shape manager to the active layer
// and set call KoSelection::setActiveLayer( KoShapeLayer* layer )
// with the parent of the active layer.
KoSelection *selection = view->canvasBase()->globalShapeManager()->selection();
Q_ASSERT(selection);
selection->deselectAll();
if (!node) {
selection->setActiveLayer(0);
imageView->setCurrentNode(0);
maskManager.activateMask(0);
layerManager.activateLayer(0);
} else {
KoShape * shape = view->document()->shapeForNode(node);
Q_ASSERT(shape);
selection->select(shape);
KoShapeLayer * shapeLayer = dynamic_cast<KoShapeLayer*>(shape);
Q_ASSERT(shapeLayer);
// shapeLayer->setGeometryProtected(node->userLocked());
// shapeLayer->setVisible(node->visible());
selection->setActiveLayer(shapeLayer);
imageView->setCurrentNode(node);
if (KisLayerSP layer = dynamic_cast<KisLayer*>(node.data())) {
maskManager.activateMask(0);
layerManager.activateLayer(layer);
} else if (KisMaskSP mask = dynamic_cast<KisMask*>(node.data())) {
maskManager.activateMask(mask);
// XXX_NODE: for now, masks cannot be nested.
layerManager.activateLayer(static_cast<KisLayer*>(node->parent().data()));
}
}
return true;
}
void KoPAView::editSelectAll()
{
KoSelection* selection = kopaCanvas()->shapeManager()->selection();
if( !selection )
return;
QList<KoShape*> shapes = activePage()->shapes();
foreach( KoShape *shape, shapes ) {
KoShapeLayer *layer = dynamic_cast<KoShapeLayer *>( shape );
if ( layer ) {
QList<KoShape*> layerShapes( layer->shapes() );
foreach( KoShape *layerShape, layerShapes ) {
selection->select( layerShape );
layerShape->update();
}
}
ShapeMoveStrategy::ShapeMoveStrategy( KoTool *tool, KoCanvasBase *canvas, const QPointF &clicked)
: KoInteractionStrategy(tool, canvas)
, m_start(clicked)
{
QList<KoShape*> selectedShapes = canvas->shapeManager()->selection()->selectedShapes(KoFlake::TopLevelSelection);
QRectF boundingRect;
foreach(KoShape *shape, selectedShapes) {
if( ! shape->isEditable() )
continue;
m_selectedShapes << shape;
m_previousPositions << shape->position();
m_newPositions << shape->position();
boundingRect = boundingRect.unite( shape->boundingRect() );
}
KoSelection * selection = m_canvas->shapeManager()->selection();
m_initialOffset = selection->absolutePosition( SelectionDecorator::hotPosition() ) - m_start;
m_initialSelectionPosition = selection->position();
m_canvas->snapGuide()->setIgnoredShapes( selection->selectedShapes( KoFlake::FullSelection ) );
tool->setStatusText( i18n("Press ALT to hold x- or y-position.") );
}
void StrokeDocker::applyChanges()
{
KoCanvasController* canvasController = KoToolManager::instance()->activeCanvasController();
KoSelection *selection = canvasController->canvas()->shapeManager()->selection();
canvasController->canvas()->resourceProvider()->setActiveBorder( d->border );
if( ! selection || ! selection->count() )
return;
KoLineBorder * newBorder = new KoLineBorder(d->border);
KoLineBorder * oldBorder = dynamic_cast<KoLineBorder*>( selection->firstSelectedShape()->border() );
if( oldBorder )
{
newBorder->setColor( oldBorder->color() );
newBorder->setLineBrush( oldBorder->lineBrush() );
}
KoShapeBorderCommand *cmd = new KoShapeBorderCommand( selection->selectedShapes(), newBorder );
canvasController->canvas()->addCommand( cmd );
}
void RefinePathPlugin::slotRefinePath()
{
KoCanvasController* canvasController = KoToolManager::instance()->activeCanvasController();
KoSelection *selection = canvasController->canvas()->shapeManager()->selection();
KoShape * shape = selection->firstSelectedShape();
if (! shape)
return;
// check if we have a path based shape
KoPathShape * path = dynamic_cast<KoPathShape*>(shape);
if (! path)
return;
// check if it is no parametric shape
KoParameterShape * ps = dynamic_cast<KoParameterShape*>(shape);
if (ps && ps->isParametricShape())
return;
if (QDialog::Rejected == m_RefinePathDlg->exec())
return;
canvasController->canvas()->addCommand(new KarbonPathRefineCommand(path, m_RefinePathDlg->knots()));
}
void KoPAView::addImages(const QList<QImage> &imageList, const QPoint &insertAt)
{
// get position from event and convert to document coordinates
QPointF pos = zoomHandler()->viewToDocument(insertAt)
+ kopaCanvas()->documentOffset() - kopaCanvas()->documentOrigin();
// create a factory
KoShapeFactoryBase *factory = KoShapeRegistry::instance()->value("PictureShape");
if (!factory) {
kWarning(30003) << "No picture shape found, cannot drop images.";
return;
}
foreach(const QImage &image, imageList) {
KoProperties params;
QVariant v;
v.setValue<QImage>(image);
params.setProperty("qimage", v);
KoShape *shape = factory->createShape(¶ms, d->doc->resourceManager());
if (!shape) {
kWarning(30003) << "Could not create a shape from the image";
return;
}
shape->setPosition(pos);
pos += QPointF(25,25); // increase the position for each shape we insert so the
// user can see them all.
KUndo2Command *cmd = kopaCanvas()->shapeController()->addShapeDirect(shape);
if (cmd) {
KoSelection *selection = kopaCanvas()->shapeManager()->selection();
selection->deselectAll();
selection->select(shape);
}
kopaCanvas()->addCommand(cmd);
}
void TestSelection::testSize()
{
KoSelection selection;
MockShape shape1;
shape1.setSize( QSizeF( 100, 100 ) );
shape1.setPosition( QPointF( 0, 0 ) );
selection.select( &shape1 );
QCOMPARE(selection.size(), QSizeF( 100, 100 ));
MockShape shape2;
shape2.setSize( QSizeF( 100, 100 ) );
shape2.setPosition( QPointF( 100, 100 ) );
selection.select( &shape2 );
QCOMPARE(selection.size(), QSizeF( 200, 200 ));
MockShape shape3;
shape3.setSize( QSizeF( 100, 100 ) );
shape3.setPosition( QPointF( 200, 200 ) );
selection.select( &shape3 );
QCOMPARE(selection.size(), QSizeF( 300, 300 ));
selection.deselect( &shape3 );
QCOMPARE(selection.size(), QSizeF( 200, 200 ));
selection.deselect( &shape2 );
QCOMPARE(selection.size(), QSizeF( 100, 100 ));
}
ShapeShearStrategy::ShapeShearStrategy( KoToolBase *tool, const QPointF &clicked, KoFlake::SelectionHandle direction )
: KoInteractionStrategy(tool)
, m_start(clicked)
{
KoSelection *sel = tool->canvas()->shapeManager()->selection();
QList<KoShape*> selectedShapes = sel->selectedShapes(KoFlake::StrippedSelection);
foreach(KoShape *shape, selectedShapes) {
if( ! shape->isEditable() )
continue;
m_selectedShapes << shape;
m_oldTransforms << shape->transformation();
}
m_initialSelectionMatrix = sel->transformation();
// Eventhoug we aren't currently activated by the corner handles we might as well code like it
switch(direction) {
case KoFlake::TopMiddleHandle:
m_top = true; m_bottom = false; m_left = false; m_right = false; break;
case KoFlake::TopRightHandle:
m_top = true; m_bottom = false; m_left = false; m_right = true; break;
case KoFlake::RightMiddleHandle:
m_top = false; m_bottom = false; m_left = false; m_right = true; break;
case KoFlake::BottomRightHandle:
m_top = false; m_bottom = true; m_left = false; m_right = true; break;
case KoFlake::BottomMiddleHandle:
m_top = false; m_bottom = true; m_left = false; m_right = false; break;
case KoFlake::BottomLeftHandle:
m_top = false; m_bottom = true; m_left = true; m_right = false; break;
case KoFlake::LeftMiddleHandle:
m_top = false; m_bottom = false; m_left = true; m_right = false; break;
case KoFlake::TopLeftHandle:
m_top = true; m_bottom = false; m_left = true; m_right = false; break;
default:
;// throw exception ? TODO
}
m_initialSize = sel->size();
m_solidPoint = QPointF( m_initialSize.width() / 2, m_initialSize.height() / 2);
if(m_top)
m_solidPoint += QPointF(0, m_initialSize.height() / 2);
else if(m_bottom)
m_solidPoint -= QPointF(0, m_initialSize.height() / 2);
if(m_left)
m_solidPoint += QPointF(m_initialSize.width() / 2, 0);
else if(m_right)
m_solidPoint -= QPointF(m_initialSize.width() / 2, 0);
QPointF edge;
qreal angle = 0.0;
if( m_top )
{
edge = sel->absolutePosition( KoFlake::BottomLeftCorner ) - sel->absolutePosition( KoFlake::BottomRightCorner );
angle = 180.0;
}
else if( m_bottom )
{
edge = sel->absolutePosition( KoFlake::TopRightCorner ) - sel->absolutePosition( KoFlake::TopLeftCorner );
angle = 0.0;
}
else if( m_left )
{
edge = sel->absolutePosition( KoFlake::BottomLeftCorner ) - sel->absolutePosition( KoFlake::TopLeftCorner );
angle = 90.0;
}
else if( m_right )
{
edge = sel->absolutePosition( KoFlake::TopRightCorner ) - sel->absolutePosition( KoFlake::BottomRightCorner );
angle = 270.0;
}
qreal currentAngle = atan2( edge.y(), edge.x() ) / M_PI * 180;
m_initialSelectionAngle = currentAngle - angle;
kDebug(30006) <<" PREsol.x=" << m_solidPoint.x() <<" sol.y=" << m_solidPoint.y();
m_solidPoint = tool->canvas()->shapeManager()->selection()->absoluteTransformation(0).map( m_solidPoint );
// use crossproduct of top edge and left edge of selection bounding rect
// to determine if the selection is mirrored
QPointF top = sel->absolutePosition( KoFlake::TopRightCorner ) - sel->absolutePosition( KoFlake::TopLeftCorner );
QPointF left = sel->absolutePosition( KoFlake::BottomLeftCorner ) - sel->absolutePosition( KoFlake::TopLeftCorner );
m_isMirrored = (top.x()*left.y() - top.y()*left.x() ) < 0.0;
}
void TestSelection::testSelectedShapes()
{
KoSelection selection;
MockShape *shape1 = new MockShape();
MockShape *shape2 = new MockShape();
MockShape *shape3 = new MockShape();
QCOMPARE(selection.count(), 0);
QCOMPARE(selection.selectedShapes().count(), 0);
selection.select(shape1);
QCOMPARE(selection.count(), 1);
QCOMPARE(selection.selectedShapes(KoFlake::FullSelection).count(), 1);
QCOMPARE(selection.selectedShapes(KoFlake::StrippedSelection).count(), 1);
QCOMPARE(selection.selectedShapes(KoFlake::TopLevelSelection).count(), 1);
selection.select(shape1); // same one.
QCOMPARE(selection.count(), 1);
QCOMPARE(selection.selectedShapes(KoFlake::FullSelection).count(), 1);
QCOMPARE(selection.selectedShapes(KoFlake::StrippedSelection).count(), 1);
QCOMPARE(selection.selectedShapes(KoFlake::TopLevelSelection).count(), 1);
selection.select(shape2);
selection.select(shape3);
QCOMPARE(selection.count(), 3);
QCOMPARE(selection.selectedShapes(KoFlake::FullSelection).count(), 3);
QCOMPARE(selection.selectedShapes(KoFlake::StrippedSelection).count(), 3);
QCOMPARE(selection.selectedShapes(KoFlake::TopLevelSelection).count(), 3);
MockGroup *group1 = new MockGroup();
group1->addShape(shape1);
group1->addShape(shape2);
selection.select(group1);
QCOMPARE(selection.count(), 3); // don't return the grouping shape.
// Stripped returns no groups, so simply all 3 shapes
QCOMPARE(selection.selectedShapes(KoFlake::FullSelection).count(), 3);
// stripped returns no groups; so simply all shapes.
QCOMPARE(selection.selectedShapes(KoFlake::StrippedSelection).count(), 3);
// toplevel returns shape3 and group1
QCOMPARE(selection.selectedShapes(KoFlake::TopLevelSelection).count(), 2);
MockGroup *group2 = new MockGroup();
group2->addShape(shape3);
group2->addShape(group1);
selection.select(group2);
QCOMPARE(selection.count(), 3); // thats 5 minus 2 grouping shapes.
// Stripped returns no groups, so simply all 3 shapes
QCOMPARE(selection.selectedShapes(KoFlake::FullSelection).count(), 3);
// Stripped returns no groups, so simply all 3 shapes
QCOMPARE(selection.selectedShapes(KoFlake::StrippedSelection).count(), 3);
// toplevel returns only group2
QCOMPARE(selection.selectedShapes(KoFlake::TopLevelSelection).count(), 1);
group1->removeShape(shape1);
group1->removeShape(shape2);
MockContainer *container = new MockContainer();
container->addShape(shape1);
container->addShape(shape2);
selection.select(container);
QCOMPARE(selection.count(), 4); // thats 6 minus 2 grouping shapes.
// Stripped returns no groups, so simply all 3 shapes + container
QCOMPARE(selection.selectedShapes(KoFlake::FullSelection).count(), 4);
// Stripped returns no groups, and no children of a container. So; container + shape3
QCOMPARE(selection.selectedShapes(KoFlake::StrippedSelection).count(), 2);
// toplevel returns only group2 + container
QCOMPARE(selection.selectedShapes(KoFlake::TopLevelSelection).count(), 2);
delete group2;
delete container;
}
