void ConnectorTool::continueRubberBanding( QMouseEvent *e )
{
KivioCanvas* canvas = view()->canvasWidget();
KivioPage* pPage = view()->activePage();
bool hit = false;
KoPoint endPoint = pPage->snapToTarget(canvas->mapFromScreen(e->pos()), 8.0, hit);
if(!hit) {
endPoint = canvas->snapToGridAndGuides(endPoint);
}
m_pDragData->x = endPoint.x();
m_pDragData->y = endPoint.y();
if(m_type == StraightConnector) {
KivioStraightConnector* connector = static_cast<KivioStraightConnector*>(m_pStencil);
connector->setEndPoint(endPoint.x(), endPoint.y());
m_pDragData->id = kctCustom + 2;
} else {
Kivio::PolyLineConnector* connector = static_cast<Kivio::PolyLineConnector*>(m_pStencil);
m_pDragData->id = kctCustom + connector->pointCount();
}
m_pStencil->customDrag(m_pDragData);
m_pStencil->updateGeometry();
canvas->repaint();
}
/**
* Tests if we should start rubber banding (always returns true).
*/
bool SMLConnector::startRubberBanding( QMouseEvent *e )
{
KivioDoc* doc = view()->doc();
KivioPage* pPage = view()->activePage();
KivioCanvas* canvas = view()->canvasWidget();
startPoint = canvas->snapToGrid(canvas->mapFromScreen( e->pos() ));
// Create the stencil
KivioStencilSpawner* ss = doc->findInternalStencilSpawner("SML Connector");
if (!ss) {
kdDebug(43000) << "SMLTool: Failed to find StencilSpawner!" << endl;
return false;
}
startPoint = canvas->snapToGrid(canvas->mapFromScreen( e->pos() ));
// Create the stencil
m_pStencil = (KivioSMLConnector*)ss->newStencil("basic_line");
m_pStencil->setTextFont(doc->defaultFont());
// Unselect everything, add the stencil to the page, and select it
pPage->unselectAllStencils();
pPage->addStencil(m_pStencil);
pPage->selectStencil(m_pStencil);
// Get drag info ready
m_pDragData = new KivioCustomDragData();
m_pDragData->page = pPage;
m_pDragData->x = startPoint.x();
m_pDragData->y = startPoint.y();
m_pDragData->id = kctCustom + 2;
m_pStencil->setStartPoint(startPoint.x() + 10.0f, startPoint.y() + 10.0f);
m_pStencil->setEndPoint(startPoint.x(), startPoint.y());
m_pStencil->customDrag(m_pDragData);
canvas->repaint();
canvas->setCursor(*m_pConnectorCursor2);
return true;
}
bool SelectTool::startCustomDragging(const QPoint &pos, bool selectedOnly )
{
KivioCanvas* canvas = view()->canvasWidget();
KivioPage *pPage = canvas->activePage();
KivioStencil *pStencil;
int colType;
KoPoint pagePoint = canvas->mapFromScreen( pos );
// Figure out how big 4 pixels is in terms of points
double threshold = view()->zoomHandler()->unzoomItY(4);
pStencil = pPage->checkForStencil( &pagePoint, &colType, threshold, selectedOnly );
if( !pStencil || colType < kctCustom ) {
return false;
}
if(pStencil->isSelected()) {
// If we are clicking an already selected stencil, and the control
// key down, then unselect this stencil
if(m_controlKey) {
pPage->unselectStencil(pStencil);
}
} else {
// Clicking a new stencil, and the control key is not down
if(!m_controlKey) {
pPage->unselectAllStencils();
}
pPage->selectStencil( pStencil );
}
m_pCustomDraggingStencil = pStencil;
// Set the mode
m_mode = stmCustomDragging;
m_customDragID = colType;
m_customDragOrigPoint = pStencil->customIDPoint(m_customDragID);
view()->canvasWidget()->setShowConnectorTargets(true);
view()->canvasWidget()->repaint();
// Create a new painter object
canvas->beginUnclippedSpawnerPainter();
m_firstTime = true;
return true;
}
void SelectTool::continueCustomDragging(const QPoint &pos)
{
KivioCanvas* canvas = view()->canvasWidget();
KoPoint pagePoint = canvas->mapFromScreen(pos);
bool hit = false;
if(m_pCustomDraggingStencil->type() == kstConnector){
pagePoint = canvas->activePage()->snapToTarget(pagePoint, 8.0, hit);
}
if(!hit) {
pagePoint = canvas->snapToGridAndGuides( pagePoint );
}
KivioCustomDragData data;
data.page = canvas->activePage();
data.dx = pagePoint.x() - m_lastPoint.x();
data.dy = pagePoint.y() - m_lastPoint.y();
data.x = pagePoint.x();
data.y = pagePoint.y();
data.id = m_customDragID;
data.scale = view()->zoomHandler()->zoomedResolutionY();
if(m_pCustomDraggingStencil->type() != kstConnector){
// Undraw the old stencils
if(!m_firstTime) {
canvas->drawStencilXOR(m_pCustomDraggingStencil);
} else {
m_pCustomDraggingStencil->setHidden(true);
canvas->repaint();
m_firstTime = false;
}
}
// Custom dragging can only occur on one stencil
if( m_pCustomDraggingStencil )
m_pCustomDraggingStencil->customDrag( &data );
// Draw the stencils
if(m_pCustomDraggingStencil->type() != kstConnector){
canvas->drawStencilXOR(m_pCustomDraggingStencil);
} else {
view()->canvasWidget()->repaint();
}
view()->updateToolBars();
}
void SelectTool::endRubberBanding(const QPoint &pos)
{
KivioCanvas* canvas = view()->canvasWidget();
// End the rubber-band drawing
canvas->endRectDraw();
KoPoint p = canvas->mapFromScreen(pos);
// We can't select if the start and end points are the same
if( m_origPoint.x() != p.x() && m_origPoint.y() != p.y() )
{
select(canvas->rect());
}
view()->updateToolBars();
}
void SMLConnector::continueRubberBanding( QMouseEvent *e )
{
KivioCanvas* canvas = view()->canvasWidget();
KoPoint endPoint = canvas->mapFromScreen( e->pos() );
endPoint = canvas->snapToGrid(endPoint);
m_pStencil->setStartPoint(endPoint.x(), endPoint.y());
m_pDragData->x = endPoint.x();
m_pDragData->y = endPoint.y();
m_pDragData->id = kctCustom + 1;
m_pStencil->customDrag(m_pDragData);
m_pStencil->updateGeometry();
canvas->repaint();
}
void ConnectorTool::mousePress( QMouseEvent *e )
{
if(e->button() == LeftButton) {
bool ok = true;
if(!m_pStencil || (m_type == StraightConnector)) {
ok = startRubberBanding(e);
} else {
if(m_pStencil) {
Kivio::PolyLineConnector* connector = static_cast<Kivio::PolyLineConnector*>(m_pStencil);
KivioCanvas* canvas = view()->canvasWidget();
KivioPage* pPage = canvas->activePage();
bool hit = false;
KoPoint point = pPage->snapToTarget(canvas->mapFromScreen(e->pos()), 8.0, hit);
if(!hit) {
point = canvas->snapToGrid(startPoint);
}
if((m_mode == stmDrawRubber) && hit) {
endRubberBanding(e);
} else {
connector->addPoint(point);
}
}
}
if(ok) {
m_mode = stmDrawRubber;
} else {
m_mode = stmNone;
}
} else if(e->button() == RightButton) {
if(m_type == PolyLineConnector) {
if(m_mode == stmDrawRubber) {
endRubberBanding(e);
}
view()->canvasWidget()->setCursor(*m_pConnectorCursor1);
m_mode = stmNone;
}
}
}
/**
* Tests if we should start rubber banding (always returns true).
*/
bool ConnectorTool::startRubberBanding( QMouseEvent *e )
{
KivioCanvas* canvas = view()->canvasWidget();
KivioDoc* doc = view()->doc();
KivioPage* pPage = canvas->activePage();
QString spawnerId;
if(m_type == StraightConnector) {
spawnerId = "Dave Marotti - Straight Connector";
} else {
spawnerId = "Internal - PolyLine Connector";
}
KivioStencilSpawner* ss = doc->findInternalStencilSpawner(spawnerId);
if(!ss) {
kdDebug(43000) << "ConnectorTool: Failed to find StencilSpawner!" << endl;
return false;
}
// Create the stencil
m_pStencil = static_cast<Kivio1DStencil*>(ss->newStencil());
bool hit = false;
startPoint = pPage->snapToTarget(canvas->mapFromScreen(e->pos()), 8.0, hit);
if(!hit) {
startPoint = canvas->snapToGrid(startPoint);
}
if(!m_pStencil) {
return false;
}
m_pStencil->setTextFont(doc->defaultFont());
// Unselect everything, add the stencil to the page, and select it
pPage->unselectAllStencils();
pPage->addStencil(m_pStencil);
pPage->selectStencil(m_pStencil);
// Get drag info ready
m_pDragData = new KivioCustomDragData();
m_pDragData->page = pPage;
m_pDragData->x = startPoint.x();
m_pDragData->y = startPoint.y();
if(m_type == StraightConnector) {
KivioStraightConnector* connector = static_cast<KivioStraightConnector*>(m_pStencil);
m_pDragData->id = kctCustom + 2;
connector->setStartPoint(startPoint.x(), startPoint.y());
connector->setEndPoint(startPoint.x() + 10.0, startPoint.y() + 10.0);
} else {
Kivio::PolyLineConnector* connector = static_cast<Kivio::PolyLineConnector*>(m_pStencil);
m_pDragData->id = kctCustom + 1;
connector->addPoint(startPoint);
connector->addPoint(startPoint);
}
m_pStencil->customDrag(m_pDragData);
canvas->repaint();
canvas->setCursor(*m_pConnectorCursor2);
return true;
}
/**
* Change the mouse cursor based on what it is over.
*/
void SelectTool::changeMouseCursor(const QPoint &pos)
{
KivioCanvas* canvas = view()->canvasWidget();
KoPoint pagePoint = canvas->mapFromScreen(pos);
KivioStencil *pStencil;
double threshold = view()->zoomHandler()->unzoomItY(4);
int cursorType;
// Iterate through all the selected stencils
pStencil = canvas->activePage()->selectedStencils()->first();
while( pStencil )
{
cursorType = isOverResizeHandle(pStencil, pagePoint.x(), pagePoint.y());
switch( cursorType )
{
case 1: // top left
canvas->setCursor( sizeFDiagCursor );
return;
case 2: // top
canvas->setCursor( sizeVerCursor );
return;
case 3: // top right
canvas->setCursor( sizeBDiagCursor );
return;
case 4: // right
canvas->setCursor( sizeHorCursor );
return;
case 5: // bottom right
canvas->setCursor( sizeFDiagCursor );
return;
case 6: // bottom
canvas->setCursor( sizeVerCursor );
return;
case 7: // bottom left
canvas->setCursor( sizeBDiagCursor );
return;
case 8: // left
canvas->setCursor( sizeHorCursor );
return;
default:
if( pStencil->checkForCollision( &pagePoint, threshold )!= kctNone )
{
canvas->setCursor( sizeAllCursor );
return;
}
break;
}
pStencil = canvas->activePage()->selectedStencils()->next();
}
canvas->unsetCursor();
}
void SelectTool::continueResizing(const QPoint &pos, bool ignoreGridGuides)
{
KivioCanvas* canvas = view()->canvasWidget();
KoPoint pagePoint = canvas->mapFromScreen(pos);
if(!ignoreGridGuides) {
pagePoint = canvas->snapToGridAndGuides( pagePoint );
}
KivioSelectDragData *pData = m_lstOldGeometry.first();
/* QWMatrix m;
double w2 = m_pResizingStencil->w() / 2.0;
double h2 = m_pResizingStencil->h() / 2.0;
m.translate(m_pResizingStencil->x(), m_pResizingStencil->y());
m.translate(m_pResizingStencil->pinPoint().x(), m_pResizingStencil->pinPoint().y());
m.rotate(-m_pResizingStencil->rotation());
m.translate(-m_pResizingStencil->pinPoint().x(), -m_pResizingStencil->pinPoint().y());
m.translate(-m_pResizingStencil->x(), -m_pResizingStencil->y());
m.invert();
double x = pagePoint.x() * m.m11() + pagePoint.y() * m.m21() + m.dx();
double y = pagePoint.x() * m.m12() + pagePoint.y() * m.m22() + m.dy();*/
if( !pData )
{
kdDebug(43000) << "SelectTool::continueResizing() - Original geometry not found" << endl;
return;
}
double dx = pagePoint.x() - m_origPoint.x();
double dy = pagePoint.y() - m_origPoint.y();
if((dx > 0) || (dy > 0) || (dx < 0) || (dy < 0)) { // Do we really need to redraw?
// Undraw the old outline
if(!m_firstTime) {
canvas->drawStencilXOR( m_pResizingStencil );
} else {
m_pResizingStencil->setHidden(true);
canvas->repaint();
m_firstTime = false;
}
double sx = pData->rect.x();
double sy = pData->rect.y();
double sw = pData->rect.width();
double sh = pData->rect.height();
double ratio = sw / sh;
switch( m_resizeHandle )
{
case 1: // top left
if( m_pResizingStencil->protection()->testBit( kpWidth )==false &&
m_pResizingStencil->protection()->testBit( kpHeight )==false )
{
if((dx > dy) && (dx != 0)) {
dy = dx / ratio;
} else {
dx = dy * ratio;
}
m_pResizingStencil->setX( sx + dx );
m_pResizingStencil->setW( sw - dx );
m_pResizingStencil->setY( sy + dy );
m_pResizingStencil->setH( sh - dy );
}
break;
case 2: // top
if( m_pResizingStencil->protection()->testBit( kpHeight )==false )
{
m_pResizingStencil->setY( sy + dy );
m_pResizingStencil->setH( sh - dy );
}
break;
case 3: // top right
if( m_pResizingStencil->protection()->testBit( kpHeight )==false &&
m_pResizingStencil->protection()->testBit( kpWidth )==false )
{
if((dx > dy) && (dx != 0)) {
dy = -(dx / ratio);
} else {
dx = -(dy * ratio);
}
m_pResizingStencil->setY( sy + dy );
m_pResizingStencil->setH( sh - dy );
m_pResizingStencil->setW( sw + dx );
}
break;
case 4: // right
if( m_pResizingStencil->protection()->testBit( kpWidth )==false )
{
// see old kivio source when snaptogrid gets implemented
//setX( SnapToGrid(sx+sw+dx)-sx )
m_pResizingStencil->setW( sw + dx );
}
break;
case 5: // bottom right
if( m_pResizingStencil->protection()->testBit( kpWidth )==false &&
m_pResizingStencil->protection()->testBit( kpHeight )==false )
{
if((dx > dy) && (dx != 0)) {
dy = dx / ratio;
} else {
dx = dy * ratio;
}
m_pResizingStencil->setW( sw + dx );
m_pResizingStencil->setH( sh + dy );
}
break;
case 6: // bottom
if( m_pResizingStencil->protection()->testBit( kpHeight )==false )
{
m_pResizingStencil->setH( sh + dy );
}
break;
case 7: // bottom left
if( m_pResizingStencil->protection()->testBit( kpWidth )==false &&
m_pResizingStencil->protection()->testBit( kpHeight )==false )
{
if((dx > dy) && (dx != 0)) {
dy = -(dx / ratio);
} else {
dx = -(dy * ratio);
}
m_pResizingStencil->setX( sx + dx );
m_pResizingStencil->setW( sw - dx );
m_pResizingStencil->setH( sh + dy );
}
break;
case 8: // left
if( m_pResizingStencil->protection()->testBit( kpWidth )==false )
{
KoPoint pinPoint = m_pResizingStencil->pinPoint();
m_pResizingStencil->setPinPoint(KoPoint(pinPoint.x() - (dx / 2.0), pinPoint.y()));
m_pResizingStencil->setX( sx + dx );
m_pResizingStencil->setW( sw - dx );
}
break;
default:
kdDebug(43000) << "SelectTool::continueResizing() - unknown resize handle: " << m_resizeHandle << endl;
break;
}
canvas->drawStencilXOR( m_pResizingStencil );
view()->updateToolBars();
}
}
/**
* Continues the dragging process of a stencil (moving)
*
* How does this work? Initially we create a list of all the original
* geometry of all the selected stencils. We use that to calculate delta
* movements and snap them to the grid.
*/
void SelectTool::continueDragging(const QPoint &pos, bool ignoreGridGuides)
{
KivioCanvas* canvas = view()->canvasWidget();
KoPoint pagePoint = canvas->mapFromScreen( pos );
double dx = pagePoint.x() - m_origPoint.x();
double dy = pagePoint.y() - m_origPoint.y();
bool snappedX;
bool snappedY;
double newX, newY;
// Undraw the old stencils
if(!m_firstTime) {
canvas->drawSelectedStencilsXOR();
} else {
canvas->activePage()->setPaintSelected(false);
canvas->repaint();
m_firstTime = false;
}
// Translate to the new position
KoPoint p;
newX = m_selectedRect.x() + dx;
newY = m_selectedRect.y() + dy;
if(!ignoreGridGuides) {
// First attempt a snap-to-grid
p.setCoords(newX, newY);
p = canvas->snapToGrid(p);
newX = p.x();
newY = p.y();
// Now the guides override the grid so we attempt to snap to them
// The bottom
p.setCoords(m_selectedRect.x() + dx + m_selectedRect.width(), m_selectedRect.y() + dy + m_selectedRect.height());
p = canvas->snapToGuides(p, snappedX, snappedY);
if(snappedX) {
newX = p.x() - m_selectedRect.width();
}
if(snappedY) {
newY = p.y() - m_selectedRect.height();
}
// The middle
p.setCoords(m_selectedRect.x() + dx + (m_selectedRect.width() / 2.0),
m_selectedRect.y() + dy + (m_selectedRect.height() / 2.0));
p = canvas->snapToGuides(p, snappedX, snappedY);
if(snappedX) {
newX = p.x() - (m_selectedRect.width() / 2.0);
}
if(snappedY) {
newY = p.y() - (m_selectedRect.height() / 2.0);
}
// The top
p.setCoords(m_selectedRect.x() + dx, m_selectedRect.y() + dy);
p = canvas->snapToGuides(p, snappedX, snappedY);
if(snappedX) {
newX = p.x();
}
if(snappedY) {
newY = p.y();
}
}
dx = newX - m_selectedRect.x();
dy = newY - m_selectedRect.y();
KivioSelectDragData *pData;
KivioStencil *pStencil = canvas->activePage()->selectedStencils()->first();
pData = m_lstOldGeometry.first();
while( pStencil && pData )
{
newX = pData->rect.x() + dx;
newY = pData->rect.y() + dy;
if( pStencil->protection()->at( kpX ) == false ) {
pStencil->setX(newX);
}
if( pStencil->protection()->at( kpY ) == false ) {
pStencil->setY(newY);
}
pData = m_lstOldGeometry.next();
pStencil = canvas->activePage()->selectedStencils()->next();
}
// Draw the stencils
canvas->drawSelectedStencilsXOR();
view()->updateToolBars();
}
/**
* Tests if we can start resizing a stencil
*/
bool SelectTool::startResizing(const QPoint &pos)
{
KivioCanvas* canvas = view()->canvasWidget();
KoPoint pagePoint = canvas->mapFromScreen(pos);
KivioSelectDragData *pData;
double x = pagePoint.x();
double y = pagePoint.y();
// Search selected stencils to see if we have a resizing point
KivioStencil *pStencil = canvas->activePage()->selectedStencils()->first();
while( pStencil )
{
m_resizeHandle = isOverResizeHandle(pStencil, x, y);
if( m_resizeHandle > 0 )
{
switch( m_resizeHandle )
{
case 1: // top left
m_origPoint.setCoords(pStencil->x(), pStencil->y());
break;
case 2:
m_origPoint.setCoords((pStencil->x() + pStencil->w()) / 2.0, pStencil->y());
break;
case 3:
m_origPoint.setCoords(pStencil->x() + pStencil->w(), pStencil->y());
break;
case 4:
m_origPoint.setCoords(pStencil->x() + pStencil->w(), (pStencil->y() + pStencil->h()) / 2.0);
break;
case 5:
m_origPoint.setCoords(pStencil->x() + pStencil->w(), pStencil->y() + pStencil->h());
break;
case 6:
m_origPoint.setCoords((pStencil->x() + pStencil->w()) / 2.0, pStencil->y() + pStencil->h());
break;
case 7:
m_origPoint.setCoords(pStencil->x(), pStencil->y() + pStencil->h());
break;
case 8:
m_origPoint.setCoords(pStencil->x(), (pStencil->y() + pStencil->h()) / 2.0);
break;
}
m_lstOldGeometry.clear();
pData = new KivioSelectDragData;
pData->rect = pStencil->rect();
m_lstOldGeometry.append(pData);
m_pResizingStencil = pStencil;
// Create a new painter object
canvas->beginUnclippedSpawnerPainter();
m_firstTime = true;
return true;
}
pStencil = canvas->activePage()->selectedStencils()->next();
}
return false;
}
/**
* Tests if we can start dragging a stencil.
*/
bool SelectTool::startDragging(const QPoint &pos, bool onlySelected)
{
KivioCanvas* canvas = view()->canvasWidget();
KivioPage *pPage = canvas->activePage();
KivioStencil *pStencil;
int colType;
// Figure out how big 4 pixels is in terms of points
double threshold = view()->zoomHandler()->unzoomItY(4);
KoPoint pagePoint = canvas->mapFromScreen( pos );
pStencil = pPage->checkForStencil( &pagePoint, &colType, threshold, onlySelected );
if( !pStencil )
return false;
canvas->setEnabled(false);
if( pStencil->isSelected() )
{
// If we are clicking an already selected stencil, and the control
// key down, then unselect this stencil
if( m_controlKey==true ) {
pPage->unselectStencil( pStencil );
}
// Otherwise, it means we are just moving
}
else
{
// Clicking a new stencil, and the control key is not down
if( !m_controlKey )
pPage->unselectAllStencils();
pPage->selectStencil( pStencil );
// Update the auto guidelines
view()->canvasWidget()->updateAutoGuideLines();
}
// Create a new painter object
canvas->beginUnclippedSpawnerPainter();
// Build the list of old geometry
KivioSelectDragData *pData;
m_lstOldGeometry.clear();
pStencil = canvas->activePage()->selectedStencils()->first();
while( pStencil )
{
pData = new KivioSelectDragData;
pData->rect = pStencil->rect();
m_lstOldGeometry.append(pData);
pStencil = canvas->activePage()->selectedStencils()->next();
}
m_selectedRect = view()->activePage()->getRectForAllSelectedStencils();
changeMouseCursor(pos);
// Set the mode
m_mode = stmDragging;
m_firstTime = true;
canvas->setEnabled(true);
return true;
}