void ResizeGesture::mouseMoveEvent(QMouseEvent *m)
{
adjustBounds(m);
FPoint where = m_canvas->globalToCanvas(m->globalPos());
if (// directly after a create the shape of an item isnt really usable, so we fix here
m_origBounds.width() < 20 || m_origBounds.height() < 20 ||
// and if we resize outside of the current canvas dimensions, we need to enlarge it
where.x() < m_doc->minCanvasCoordinate.x() || where.y() < m_doc->minCanvasCoordinate.y() ||
where.x() > m_doc->maxCanvasCoordinate.x() || where.y() > m_doc->maxCanvasCoordinate.y())
{
doResize(m->modifiers() & Qt::AltModifier);
}
m->accept();
QPoint point = m->globalPos() - (m_canvas->mapToParent(QPoint(0, 0)) + m_canvas->parentWidget()->mapToGlobal(QPoint(0, 0)));
m_view->ensureVisible(point.x(), point.y(), 20, 20);
m_canvas->repaint();
QRectF newBounds = m_bounds.normalized();
m_canvas->displaySizeHUD(m->globalPos(), newBounds.width() - m_extraWidth, newBounds.height() - m_extraHeight);
}
void CanvasMode_ObjImport::mouseReleaseEvent(QMouseEvent *m)
{
m_canvas->m_viewMode.m_MouseButtonPressed = false;
m_canvas->resetRenderMode();
m->accept();
if ((m->button() == Qt::LeftButton) && m_mimeData)
{
UndoTransaction undoTransaction;
if (m_trSettings && UndoManager::undoEnabled())
{
undoTransaction = UndoManager::instance()->beginTransaction(*m_trSettings);
}
// Creating QDragEnterEvent outside of Qt is not recommended per docs :S
QPoint dropPos = m_view->widget()->mapFromGlobal(m->globalPos());
const FPoint mousePointDoc = m_canvas->globalToCanvas(m->globalPos());
QDropEvent dropEvent(dropPos, Qt::CopyAction|Qt::MoveAction, m_mimeData, m->buttons(), m->modifiers());
m_view->contentsDropEvent(&dropEvent);
if (m_doc->m_Selection->count() > 0)
{
double gx, gy, gh, gw;
m_doc->m_Selection->getGroupRect(&gx, &gy, &gw, &gh);
m_doc->moveGroup(mousePointDoc.x() - gx, mousePointDoc.y() -gy);
}
// Commit undo transaction if necessary
if (undoTransaction)
{
undoTransaction.commit();
}
// Return to normal mode
m_view->requestMode(modeNormal);
}
// m_view->stopDragTimer();
m_canvas->setRenderModeUseBuffer(false);
m_doc->DragP = false;
m_doc->leaveDrag = false;
m_canvas->m_viewMode.operItemMoving = false;
m_canvas->m_viewMode.operItemResizing = false;
m_view->MidButt = false;
//Make sure the Zoom spinbox and page selector dont have focus if we click on the canvas
m_view->m_ScMW->zoomSpinBox->clearFocus();
m_view->m_ScMW->pageSelector->clearFocus();
}
void CanvasMode_FrameLinks::mouseReleaseEvent(QMouseEvent *m)
{
#ifdef GESTURE_FRAME_PREVIEW
clearPixmapCache();
#endif // GESTURE_FRAME_PREVIEW
const FPoint mousePointDoc = m_canvas->globalToCanvas(m->globalPos());
PageItem *currItem;
m_canvas->m_viewMode.m_MouseButtonPressed = false;
m_canvas->resetRenderMode();
m->accept();
// m_view->stopDragTimer();
//m_canvas->update(); //ugly in a mouseReleaseEvent!!!!!!!
if ((GetItem(&currItem)) && (m->button() == Qt::RightButton) && (!m_doc->DragP))
{
createContextMenu(currItem, mousePointDoc.x(), mousePointDoc.y());
return;
}
if ((m_doc->appMode == modeLinkFrames) || (m_doc->appMode == modeUnlinkFrames))
{
m_view->updateContents();
if (m_doc->ElemToLink != 0)
return;
else
{
m_view->requestMode(submodePaintingDone);
return;
}
}
m_canvas->setRenderModeUseBuffer(false);
m_doc->DragP = false;
m_doc->leaveDrag = false;
m_canvas->m_viewMode.operItemMoving = false;
m_canvas->m_viewMode.operItemResizing = false;
m_view->MidButt = false;
for (int i = 0; i < m_doc->m_Selection->count(); ++i)
m_doc->m_Selection->itemAt(i)->checkChanges(true);
//Make sure the Zoom spinbox and page selector dont have focus if we click on the canvas
m_view->zoomSpinBox->clearFocus();
m_view->pageSelector->clearFocus();
}
void CanvasMode_EditWeldPoint::mousePressEvent(QMouseEvent *m)
{
const FPoint mousePointDoc = m_canvas->globalToCanvas(m->globalPos());
m_canvas->PaintSizeRect(QRect());
m_canvas->m_viewMode.m_MouseButtonPressed = true;
m_canvas->m_viewMode.operItemMoving = false;
m_view->HaveSelRect = false;
m_doc->DragP = false;
m_doc->leaveDrag = false;
m->accept();
m_view->registerMousePress(m->globalPos());
m_Mxp = mousePointDoc.x(); //m->x();
m_Myp = mousePointDoc.y(); //m->y();
if (m->button() == Qt::MidButton)
{
m_view->MidButt = true;
if (m->modifiers() & Qt::ControlModifier)
m_view->DrawNew();
return;
}
QTransform itemMatrix;
m_currItem = m_doc->m_Selection->itemAt(0);
itemMatrix.translate(m_currItem->xPos(), m_currItem->yPos());
itemMatrix.rotate(m_currItem->rotation());
m_selectedPoint = -1;
for (int i = 0 ; i < m_currItem->weldList.count(); i++)
{
PageItem::WeldingInfo wInf = m_currItem->weldList.at(i);
if (m_canvas->hitsCanvasPoint(mousePointDoc, itemMatrix.map(QPointF(wInf.weldPoint.x(), wInf.weldPoint.y()))))
{
m_selectedPoint = i;
break;
}
}
m_canvas->m_viewMode.m_MouseButtonPressed = true;
m_view->setCursor(QCursor(Qt::CrossCursor));
m_doc->regionsChanged()->update(getUpdateRect());
}
void CanvasMode_EditSpiral::mousePressEvent(QMouseEvent *m)
{
const FPoint mousePointDoc = m_canvas->globalToCanvas(m->globalPos());
m_canvas->PaintSizeRect(QRect());
m_canvas->m_viewMode.m_MouseButtonPressed = true;
m_canvas->m_viewMode.operItemMoving = false;
m_view->HaveSelRect = false;
m_doc->DragP = false;
m_doc->leaveDrag = false;
m->accept();
m_view->registerMousePress(m->globalPos());
m_Mxp = mousePointDoc.x(); //m->x();
m_Myp = mousePointDoc.y(); //m->y();
if (m->button() == Qt::MidButton)
{
m_view->MidButt = true;
if (m->modifiers() & Qt::ControlModifier)
m_view->DrawNew();
return;
}
PageItem *currItem = m_doc->m_Selection->itemAt(0);
QTransform itemMatrix = currItem->getTransform();
QPointF stPoint = m_startPoint;
stPoint = itemMatrix.map(stPoint);
QPointF swPoint = m_endPoint;
swPoint = itemMatrix.map(swPoint);
if (m_canvas->hitsCanvasPoint(m->globalPos(), stPoint))
m_arcPoint = useControlStart;
else if (m_canvas->hitsCanvasPoint(m->globalPos(), swPoint))
m_arcPoint = useControlEnd;
else
m_arcPoint = noPointDefined;
if (m_arcPoint != noPointDefined)
m_transaction = undoManager->beginTransaction(Um::Polygon, Um::IPolygon, Um::EditSpiral, "", Um::IPolygon);
m_canvas->m_viewMode.m_MouseButtonPressed = true;
m_view->setCursor(QCursor(Qt::CrossCursor));
m_doc->regionsChanged()->update(itemMatrix.mapRect(QRectF(0, 0, currItem->width(), currItem->height())).adjusted(-5, -5, 10, 10));
}
void ScrPainter::finishItem(PageItem* ite)
{
ite->ClipEdited = true;
ite->FrameType = 3;
ite->setFillShade(CurrFillShade);
ite->setFillEvenOdd(fillrule);
ite->setLineShade(CurrStrokeShade);
ite->setLineJoin(lineJoin);
ite->setLineEnd(lineEnd);
ite->DashValues = dashArray;
FPoint wh = getMaxClipF(&ite->PoLine);
ite->setWidthHeight(wh.x(),wh.y());
ite->setTextFlowMode(PageItem::TextFlowDisabled);
m_Doc->AdjustItemSize(ite);
ite->OldB2 = ite->width();
ite->OldH2 = ite->height();
if (isGradient)
{
ite->fill_gradient = currentGradient;
ite->GrType = 6;
QTransform m1;
m1.rotate(-gradientAngle);
ite->GrStartX = 0;
ite->GrStartY = 0;
QPointF target = m1.map(QPointF(0.0, ite->height()));
ite->GrEndX = target.x();
ite->GrEndY = target.y();
}
else
{
ite->setFillTransparency(CurrFillTrans);
ite->setLineTransparency(CurrStrokeTrans);
}
ite->updateClip();
Elements.append(ite);
Coords.resize(0);
Coords.svgInit();
}
void CanvasMode_FrameLinks::mouseMoveEvent(QMouseEvent *m)
{
const FPoint mousePointDoc = m_canvas->globalToCanvas(m->globalPos());
m->accept();
if (commonMouseMove(m))
return;
if ((m_canvas->m_viewMode.m_MouseButtonPressed) && (m->buttons() & Qt::LeftButton))
{
SeRx = qRound(mousePointDoc.x()); //m_view->translateToDoc(m->x(), m->y()).x());
SeRy = qRound(mousePointDoc.y()); //m_view->translateToDoc(m->x(), m->y()).y());
/*
m_view->redrawMarker->setGeometry(QRect(Mxp, Myp, m->globalPos().x() - Mxp, m->globalPos().y() - Myp).normalized());
*/
QPoint startP = m_canvas->canvasToGlobal(m_doc->appMode == modeDrawTable || m_doc->appMode == modeDrawTable2 ? QPointF(Dxp, Dyp) : QPointF(Mxp, Myp));
m_view->redrawMarker->setGeometry(QRect(startP, m->globalPos()).normalized());
if (!m_view->redrawMarker->isVisible())
m_view->redrawMarker->show();
m_view->HaveSelRect = true;
return;
}
}
void CanvasMode_EditWeldPoint::mouseMoveEvent(QMouseEvent *m)
{
const FPoint mousePointDoc = m_canvas->globalToCanvas(m->globalPos());
m->accept();
FPoint npfN;
double nx = mousePointDoc.x();
double ny = mousePointDoc.y();
if (!m_doc->ApplyGuides(&nx, &ny) && !m_doc->ApplyGuides(&nx, &ny,true))
npfN = m_doc->ApplyGridF(FPoint(nx, ny));
else
npfN = FPoint(nx, ny);
m_currItem = m_doc->m_Selection->itemAt(0);
FPoint npf = FPoint(npfN.x(), npfN.y(), m_currItem->xPos(), m_currItem->yPos(), m_currItem->rotation(), 1, 1, true);
FPoint npx(m_Mxp - npfN.x(), m_Myp - npfN.y(), 0, 0, m_currItem->rotation(), 1, 1, true);
m_canvas->displayXYHUD(m->globalPos(), npf.x(), npf.y());
if (m_canvas->m_viewMode.m_MouseButtonPressed && m_view->moveTimerElapsed())
{
if (m_editWeldMode)
{
if (m_selectedPoint != -1)
{
m_canvas->displayXYHUD(m->globalPos(), npf.x(), npf.y());
FPoint mp, mp_orig;
mp_orig = m_currItem->weldList[m_selectedPoint].weldPoint;
mp = mp_orig - npx;
double xx = mp.x();
double yy = mp.y();
snapToEdgePoints(xx, yy);
m_currItem->weldList[m_selectedPoint].weldPoint = FPoint(xx, yy);
}
}
else
{
m_currItem->setXYPos(m_currItem->xPos() - npx.x(), m_currItem->yPos() - npx.y(), true);
m_currItem->setRedrawBounding();
m_currItem->OwnPage = m_doc->OnPage(m_currItem);
}
m_doc->regionsChanged()->update(getUpdateRect());
}
m_Mxp = npfN.x();
m_Myp = npfN.y();
}
void CalligraphicMode::mouseReleaseEvent(QMouseEvent *m)
{
undoManager->setUndoEnabled(true);
PageItem *currItem;
m_MouseButtonPressed = false;
m_canvas->resetRenderMode();
m->accept();
if (m_doc->appMode == modeDrawCalligraphicLine)
{
if (RecordP.size() > 1)
{
UndoTransaction createTransaction;
if (UndoManager::undoEnabled())
createTransaction = UndoManager::instance()->beginTransaction();
uint z = m_doc->itemAdd(PageItem::Polygon, PageItem::Unspecified, Mxp, Myp, 1, 1, m_doc->itemToolPrefs().calligraphicPenLineWidth, m_doc->itemToolPrefs().calligraphicPenFillColor, m_doc->itemToolPrefs().calligraphicPenLineColor);
currItem = m_doc->Items->at(z);
currItem->PoLine.resize(0);
QList<QPointF> clipU;
QList<QPointF> clipL;
double mx = sin(m_doc->itemToolPrefs().calligraphicPenAngle / 180.0 * M_PI) * (m_doc->itemToolPrefs().calligraphicPenWidth / 2.0);
double my = cos(m_doc->itemToolPrefs().calligraphicPenAngle / 180.0 * M_PI) * (m_doc->itemToolPrefs().calligraphicPenWidth / 2.0);
for (int px = 0; px < RecordP.size()-1; ++px)
{
FPoint clp = RecordP.point(px);
clipU.append(QPointF(clp.x() - mx, clp.y() - my));
clipL.prepend(QPointF(clp.x() + mx, clp.y() + my));
}
QPainterPath ppU = bezierFit(clipU, 5.0);
QPainterPath ppL = bezierFit(clipL, 5.0);
QPainterPath pp;
pp.addPath(ppU);
pp.connectPath(ppL);
pp.closeSubpath();
currItem->PoLine.fromQPainterPath(pp);
FPoint tp2(getMinClipF(&currItem->PoLine));
currItem->setXYPos(tp2.x(), tp2.y(), true);
currItem->PoLine.translate(-tp2.x(), -tp2.y());
FPoint tp(getMaxClipF(&currItem->PoLine));
m_doc->sizeItem(tp.x(), tp.y(), currItem, false, false, false);
m_doc->adjustItemSize(currItem);
m_doc->m_Selection->clear();
m_doc->m_Selection->addItem(currItem);
currItem->ClipEdited = true;
currItem->FrameType = 3;
currItem->OwnPage = m_doc->OnPage(currItem);
currItem->PLineArt = Qt::PenStyle(m_doc->itemToolPrefs().calligraphicPenStyle);
currItem->setFillShade(m_doc->itemToolPrefs().calligraphicPenFillColorShade);
currItem->setLineShade(m_doc->itemToolPrefs().calligraphicPenLineColorShade);
currItem->setFillEvenOdd(true);
m_view->resetMousePressed();
currItem->checkChanges();
QString targetName = Um::ScratchSpace;
if (currItem->OwnPage > -1)
targetName = m_doc->Pages->at(currItem->OwnPage)->getUName();
if (createTransaction)
createTransaction.commit(targetName, currItem->getUPixmap(), Um::Create + " " + currItem->getUName(), "", Um::ICreate);
//FIXME
m_canvas->m_viewMode.operItemResizing = false;
m_doc->changed();
}
if (!PrefsManager::instance()->appPrefs.uiPrefs.stickyTools)
{
m_view->requestMode(modeNormal);
}
else
m_view->requestMode(m_doc->appMode);
return;
}
m_canvas->setRenderModeUseBuffer(false);
m_doc->DragP = false;
m_doc->leaveDrag = false;
m_view->MidButt = false;
if (m_view->groupTransactionStarted())
{
for (int i = 0; i < m_doc->m_Selection->count(); ++i)
m_doc->m_Selection->itemAt(i)->checkChanges(true);
m_view->endGroupTransaction();
}
for (int i = 0; i < m_doc->m_Selection->count(); ++i)
m_doc->m_Selection->itemAt(i)->checkChanges(true);
//Commit drag created items to undo manager.
if (m_doc->m_Selection->itemAt(0)!=NULL)
{
m_doc->itemAddCommit(m_doc->m_Selection->itemAt(0));
}
//Make sure the Zoom spinbox and page selector don't have focus if we click on the canvas
m_view->m_ScMW->zoomSpinBox->clearFocus();
m_view->m_ScMW->pageSelector->clearFocus();
if (m_doc->m_Selection->itemAt(0) != 0) // is there the old clip stored for the undo action
{
currItem = m_doc->m_Selection->itemAt(0);
m_doc->nodeEdit.finishTransaction(currItem);
}
}
void CalligraphicMode::mouseMoveEvent(QMouseEvent *m)
{
const FPoint mousePointDoc = m_canvas->globalToCanvas(m->globalPos());
double newX, newY;
PageItem *currItem;
QPoint np, np2, mop;
FPoint npf, npf2;
QRect tx;
m->accept();
m_canvas->displayCorrectedXYHUD(m->globalPos(), mousePointDoc.x(), mousePointDoc.y());
if (commonMouseMove(m))
return;
if (m_MouseButtonPressed && (m_doc->appMode == modeDrawCalligraphicLine))
{
double newXF = mousePointDoc.x(); //m_view->translateToDoc(m->x(), m->y()).x();
double newYF = mousePointDoc.y(); //m_view->translateToDoc(m->x(), m->y()).y();
if (RecordP.size() > 0)
{
if (FPoint(newXF, newYF) != RecordP.point(RecordP.size()-1))
RecordP.addPoint(FPoint(newXF, newYF));
}
else
RecordP.addPoint(FPoint(newXF, newYF));
QPolygon& redrawPolygon(m_canvas->newRedrawPolygon());
double mx = sin(m_doc->itemToolPrefs().calligraphicPenAngle / 180.0 * M_PI) * (m_doc->itemToolPrefs().calligraphicPenWidth / 2.0);
double my = cos(m_doc->itemToolPrefs().calligraphicPenAngle / 180.0 * M_PI) * (m_doc->itemToolPrefs().calligraphicPenWidth / 2.0);
for (int px = 0; px < RecordP.size()-1; ++px)
{
FPoint clp = RecordP.point(px);
redrawPolygon.append(QPoint(qRound(clp.x() - mx), qRound(clp.y() - my)));
redrawPolygon.prepend(QPoint(qRound(clp.x() + mx), qRound(clp.y() + my)));
}
redrawPolygon.append(QPoint(qRound(RecordP.point(RecordP.size()-1).x() + mx), qRound(RecordP.point(RecordP.size()-1).y() + my)));
//FIXME
m_canvas->m_viewMode.operItemResizing = true;
QRect bRect = m_canvas->redrawPolygon().boundingRect();
m_view->updateCanvas(bRect);
return;
}
if (GetItem(&currItem))
{
newX = qRound(mousePointDoc.x()); //m_view->translateToDoc(m->x(), m->y()).x());
newY = qRound(mousePointDoc.y()); //m_view->translateToDoc(m->x(), m->y()).y());
if (m_doc->DragP)
return;
if ((!m_MouseButtonPressed) && (m_doc->appMode != modeDrawBezierLine))
{
if (m_doc->m_Selection->isMultipleSelection())
{
setModeCursor();
return;
}
for (int a = 0; a < m_doc->m_Selection->count(); ++a)
{
currItem = m_doc->m_Selection->itemAt(a);
if (currItem->locked())
break;
setModeCursor();
}
}
}
else
{
if ((m_MouseButtonPressed) && (m->buttons() & Qt::LeftButton))
{
newX = qRound(mousePointDoc.x()); //m_view->translateToDoc(m->x(), m->y()).x());
newY = qRound(mousePointDoc.y()); //m_view->translateToDoc(m->x(), m->y()).y());
SeRx = newX;
SeRy = newY;
QPoint startP = m_canvas->canvasToGlobal(m_doc->appMode == modeDrawTable2 ? QPointF(Dxp, Dyp) : QPointF(Mxp, Myp));
m_view->redrawMarker->setGeometry(QRect(m_view->mapFromGlobal(startP), m_view->mapFromGlobal(m->globalPos())).normalized());
m_view->setRedrawMarkerShown(true);
m_view->HaveSelRect = true;
return;
}
}
}
//CB-->Doc/Fix
bool CanvasMode_CopyProperties::SeleItem(QMouseEvent *m)
{
const unsigned SELECT_IN_GROUP = Qt::AltModifier;
const unsigned SELECT_MULTIPLE = Qt::ShiftModifier;
const unsigned SELECT_BENEATH = Qt::ControlModifier;
PageItem *currItem;
m_canvas->m_viewMode.m_MouseButtonPressed = true;
FPoint mousePointDoc = m_canvas->globalToCanvas(m->globalPos());
Mxp = mousePointDoc.x(); //m->x()/m_canvas->scale());
Myp = mousePointDoc.y(); //m->y()/m_canvas->scale());
int MxpS = static_cast<int>(mousePointDoc.x()); //m->x()/m_canvas->scale() + 0*m_doc->minCanvasCoordinate.x());
int MypS = static_cast<int>(mousePointDoc.y()); //m->y()/m_canvas->scale() + 0*m_doc->minCanvasCoordinate.y());
m_doc->nodeEdit.deselect();
if (!m_doc->masterPageMode())
{
int pgNum = -1;
int docPageCount = static_cast<int>(m_doc->Pages->count() - 1);
MarginStruct pageBleeds;
bool drawBleed = false;
if (m_doc->bleeds()->hasNonZeroValue() && m_doc->guidesPrefs().showBleed)
drawBleed = true;
for (int a = docPageCount; a > -1; a--)
{
if (drawBleed)
m_doc->getBleeds(a, pageBleeds);
int x = static_cast<int>(m_doc->Pages->at(a)->xOffset() - pageBleeds.Left);
int y = static_cast<int>(m_doc->Pages->at(a)->yOffset() - pageBleeds.Top);
int w = static_cast<int>(m_doc->Pages->at(a)->width() + pageBleeds.Left + pageBleeds.Right);
int h = static_cast<int>(m_doc->Pages->at(a)->height() + pageBleeds.Bottom + pageBleeds.Top);
if (QRect(x, y, w, h).contains(MxpS, MypS))
{
pgNum = static_cast<int>(a);
if (drawBleed) // check again if its really on the correct page
{
for (int a2 = docPageCount; a2 > -1; a2--)
{
int xn = static_cast<int>(m_doc->Pages->at(a2)->xOffset());
int yn = static_cast<int>(m_doc->Pages->at(a2)->yOffset());
int wn = static_cast<int>(m_doc->Pages->at(a2)->width());
int hn = static_cast<int>(m_doc->Pages->at(a2)->height());
if (QRect(xn, yn, wn, hn).contains(MxpS, MypS))
{
pgNum = static_cast<int>(a2);
break;
}
}
}
break;
}
}
if (pgNum >= 0)
{
if (m_doc->currentPageNumber() != pgNum)
{
m_doc->setCurrentPage(m_doc->Pages->at(unsigned(pgNum)));
m_view->setMenTxt(unsigned(pgNum));
m_view->DrawNew();
}
}
m_view->setRulerPos(m_view->contentsX(), m_view->contentsY());
}
currItem = NULL;
if ((m->modifiers() & SELECT_BENEATH) != 0)
{
for (int i=0; i < m_doc->m_Selection->count(); ++i)
{
if (m_canvas->frameHitTest(QPointF(mousePointDoc.x(),mousePointDoc.y()), m_doc->m_Selection->itemAt(i)) >= 0)
{
currItem = m_doc->m_Selection->itemAt(i);
m_doc->m_Selection->removeItem(currItem);
break;
}
}
}
else if ( (m->modifiers() & SELECT_MULTIPLE) == Qt::NoModifier || (m_doc->appMode == modeLinkFrames) || (m_doc->appMode == modeUnlinkFrames) )
{
m_view->Deselect(false);
}
currItem = m_canvas->itemUnderCursor(m->globalPos(), currItem, (m->modifiers() & SELECT_IN_GROUP));
if (currItem)
{
m_doc->m_Selection->delaySignalsOn();
if (m_doc->m_Selection->containsItem(currItem))
{
m_doc->m_Selection->removeItem(currItem);
}
else
{
//CB: If we have a selection but the user clicks with control on another item that is not below the current
//then clear and select the new item
if ((m->modifiers() == SELECT_BENEATH) && m_canvas->frameHitTest(QPointF(mousePointDoc.x(),mousePointDoc.y()), currItem) >= 0)
m_doc->m_Selection->clear();
m_doc->m_Selection->addItem(currItem);
if ( (m->modifiers() & SELECT_IN_GROUP) && (!currItem->isGroup()))
{
currItem->isSingleSel = true;
}
}
currItem->update();
m_doc->m_Selection->delaySignalsOff();
if (m_doc->m_Selection->count() > 1)
{
for (int aa = 0; aa < m_doc->m_Selection->count(); ++aa)
{
PageItem *bb = m_doc->m_Selection->itemAt(aa);
bb->update();
}
m_doc->m_Selection->setGroupRect();
double x, y, w, h;
m_doc->m_Selection->getGroupRect(&x, &y, &w, &h);
m_view->getGroupRectScreen(&x, &y, &w, &h);
}
if (m_doc->m_Selection->count() == 1)
{
frameResizeHandle = m_canvas->frameHitTest(QPointF(mousePointDoc.x(),mousePointDoc.y()), currItem);
if ((frameResizeHandle == Canvas::INSIDE) && (!currItem->locked()))
qApp->changeOverrideCursor(QCursor(Qt::SizeAllCursor));
}
else
{
qApp->changeOverrideCursor(QCursor(Qt::SizeAllCursor));
m_canvas->m_viewMode.operItemResizing = false;
}
return true;
}
m_doc->m_Selection->connectItemToGUI();
if ( !(m->modifiers() & SELECT_MULTIPLE) || (m_doc->appMode == modeLinkFrames) || (m_doc->appMode == modeUnlinkFrames))
m_view->Deselect(true);
return false;
}
void CanvasMode_CopyProperties::mousePressEvent(QMouseEvent *m)
{
// const double mouseX = m->globalX();
// const double mouseY = m->globalY();
const FPoint mousePointDoc = m_canvas->globalToCanvas(m->globalPos());
double Rxp = 0, Ryp = 0;
PageItem *currItem;
m_canvas->PaintSizeRect(QRect());
m_canvas->m_viewMode.m_MouseButtonPressed = true;
m_canvas->m_viewMode.operItemMoving = false;
m_view->HaveSelRect = false;
m_doc->DragP = false;
m_doc->leaveDrag = false;
m->accept();
m_view->registerMousePress(m->globalPos());
Mxp = mousePointDoc.x(); //qRound(m->x()/m_canvas->scale() + 0*m_doc->minCanvasCoordinate.x());
Myp = mousePointDoc.y(); //qRound(m->y()/m_canvas->scale() + 0*m_doc->minCanvasCoordinate.y());
Rxp = m_doc->ApplyGridF(FPoint(Mxp, Myp)).x();
Mxp = qRound(Rxp);
Ryp = m_doc->ApplyGridF(FPoint(Mxp, Myp)).y();
Myp = qRound(Ryp);
if (m->button() == Qt::MidButton)
{
m_view->MidButt = true;
if (m->modifiers() & Qt::ControlModifier)
m_view->DrawNew();
return;
}
if (m->button() != Qt::LeftButton)
return;
SeleItem(m);
if (GetItem(&currItem))
{
double sx, sy, ex, ey, r, skx, sky, fx, fy, ss, sk, sp;
currItem->ColGap = m_doc->ElemToLink->ColGap;
currItem->Cols = m_doc->ElemToLink->Cols;
currItem->BottomLine = m_doc->ElemToLink->BottomLine;
currItem->TopLine = m_doc->ElemToLink->TopLine;
currItem->LeftLine = m_doc->ElemToLink->LeftLine;
currItem->RightLine = m_doc->ElemToLink->RightLine;
currItem->setTextToFrameDist(m_doc->ElemToLink->textToFrameDistLeft(), m_doc->ElemToLink->textToFrameDistRight(), m_doc->ElemToLink->textToFrameDistTop(), m_doc->ElemToLink->textToFrameDistBottom());
// Stroke Properties
currItem->setLineStyle(m_doc->ElemToLink->lineStyle());
currItem->setLineWidth(m_doc->ElemToLink->lineWidth());
currItem->setLineTransparency(m_doc->ElemToLink->lineTransparency());
currItem->setLineShade(m_doc->ElemToLink->lineShade());
currItem->setLineColor(m_doc->ElemToLink->lineColor());
currItem->setLineEnd(m_doc->ElemToLink->lineEnd());
currItem->setLineJoin(m_doc->ElemToLink->lineJoin());
currItem->setCustomLineStyle(m_doc->ElemToLink->customLineStyle());
currItem->setEndArrowIndex(m_doc->ElemToLink->endArrowIndex());
currItem->setStartArrowIndex(m_doc->ElemToLink->startArrowIndex());
currItem->setEndArrowScale(m_doc->ElemToLink->endArrowScale());
currItem->setStartArrowScale(m_doc->ElemToLink->startArrowScale());
// Fill Properties
currItem->setFillColor(m_doc->ElemToLink->fillColor());
currItem->setFillShade(m_doc->ElemToLink->fillShade());
currItem->setFillTransparency(m_doc->ElemToLink->fillTransparency());
// Gradient Properties
currItem->fill_gradient = m_doc->ElemToLink->fill_gradient;
currItem->setGradient(m_doc->ElemToLink->gradient());
m_doc->ElemToLink->gradientVector(sx, sy, ex, ey, fx, fy, ss, sk);
currItem->setGradientVector(sx, sy, ex, ey, fx, fy, ss, sk);
// Pattern Properties
currItem->setPattern(m_doc->ElemToLink->pattern());
m_doc->ElemToLink->patternTransform(sx, sy, ex, ey, r, skx, sky);
currItem->setPatternTransform(sx, sy, ex, ey, r, skx, sky);
currItem->setStrokePattern(m_doc->ElemToLink->strokePattern());
m_doc->ElemToLink->strokePatternTransform(sx, sy, ex, ey, r, skx, sky, sp);
currItem->setStrokePatternTransform(sx, sy, ex, ey, r, skx, sky, sp);
currItem->setStrokePatternToPath(m_doc->ElemToLink->isStrokePatternToPath());
// Set Gradient type after all properties
currItem->setGradientType(m_doc->ElemToLink->gradientType());
currItem->stroke_gradient = m_doc->ElemToLink->stroke_gradient;
currItem->setStrokeGradient(m_doc->ElemToLink->strokeGradient());
m_doc->ElemToLink->strokeGradientVector(sx, sy, ex, ey, fx, fy, ss, sk);
currItem->setStrokeGradientVector(sx, sy, ex, ey, fx, fy, ss, sk);
currItem->setStrokeGradientType(m_doc->ElemToLink->strokeGradientType());
// Update Item
m_doc->ElemToLink = currItem;
currItem->update();
// emit DocChanged();
// m_view->updateContents();
}
else
{
m_doc->ElemToLink = NULL;
m_view->requestMode(submodePaintingDone);
}
}
void PageItem_PathText::DrawObj_Item(ScPainter *p, QRectF cullingArea)
{
itemText.invalidateAll();
firstChar = 0;
MaxChars = 0;
int a;
QString chstr, chstr2, chstr3;
double dx;
FPoint point = FPoint(0, 0);
FPoint tangent = FPoint(0, 0);
QColor tmp;
CurX = m_textDistanceMargins.left();
QString cachedStroke = "";
QString cachedFill = "";
double cachedFillShade = -1;
double cachedStrokeShade = -1;
QString actStroke = "";
QString actFill = "";
double actFillShade = -1;
double actStrokeShade = -1;
QColor cachedFillQ;
QColor cachedStrokeQ;
if (!m_Doc->layerOutline(LayerID))
{
if (PoShow)
{
p->setupPolygon(&PoLine, false);
if (NamedLStyle.isEmpty())
{
if ((!patternStrokeVal.isEmpty()) && (m_Doc->docPatterns.contains(patternStrokeVal)))
{
if (patternStrokePath)
{
QPainterPath guidePath = PoLine.toQPainterPath(false);
DrawStrokePattern(p, guidePath);
}
else
{
p->setPattern(&m_Doc->docPatterns[patternStrokeVal], patternStrokeScaleX, patternStrokeScaleY, patternStrokeOffsetX, patternStrokeOffsetY, patternStrokeRotation, patternStrokeSkewX, patternStrokeSkewY, patternStrokeMirrorX, patternStrokeMirrorY);
p->setStrokeMode(ScPainter::Pattern);
p->strokePath();
}
}
else if (GrTypeStroke > 0)
{
if ((!gradientStrokeVal.isEmpty()) && (!m_Doc->docGradients.contains(gradientStrokeVal)))
gradientStrokeVal = "";
if (!(gradientStrokeVal.isEmpty()) && (m_Doc->docGradients.contains(gradientStrokeVal)))
stroke_gradient = m_Doc->docGradients[gradientStrokeVal];
if (stroke_gradient.Stops() < 2) // fall back to solid stroking if there are not enough colorstops in the gradient.
{
if (lineColor() != CommonStrings::None)
{
p->setBrush(strokeQColor);
p->setStrokeMode(ScPainter::Solid);
}
else
p->setStrokeMode(ScPainter::None);
}
else
{
p->setStrokeMode(ScPainter::Gradient);
p->stroke_gradient = stroke_gradient;
if (GrTypeStroke == 6)
p->setGradient(VGradient::linear, FPoint(GrStrokeStartX, GrStrokeStartY), FPoint(GrStrokeEndX, GrStrokeEndY), FPoint(GrStrokeStartX, GrStrokeStartY), GrStrokeScale, GrStrokeSkew);
else
p->setGradient(VGradient::radial, FPoint(GrStrokeStartX, GrStrokeStartY), FPoint(GrStrokeEndX, GrStrokeEndY), FPoint(GrStrokeFocalX, GrStrokeFocalY), GrStrokeScale, GrStrokeSkew);
}
p->strokePath();
}
else if (lineColor() != CommonStrings::None)
{
p->setStrokeMode(ScPainter::Solid);
p->strokePath();
}
}
else
{
p->setStrokeMode(ScPainter::Solid);
multiLine ml = m_Doc->MLineStyles[NamedLStyle];
QColor tmp;
for (int it = ml.size()-1; it > -1; it--)
{
if (ml[it].Color != CommonStrings::None) // && (ml[it].Width != 0))
{
SetQColor(&tmp, ml[it].Color, ml[it].Shade);
p->setPen(tmp, ml[it].Width, static_cast<Qt::PenStyle>(ml[it].Dash), static_cast<Qt::PenCapStyle>(ml[it].LineEnd), static_cast<Qt::PenJoinStyle>(ml[it].LineJoin));
p->strokePath();
}
}
}
}
}
double totalTextLen = 0.0;
double totalCurveLen = 0.0;
double extraOffset = 0.0;
if (itemText.length() != 0)
{
CurX += itemText.charStyle(0).fontSize() * itemText.charStyle(0).tracking() / 10000.0;
totalTextLen += itemText.charStyle(0).fontSize() * itemText.charStyle(0).tracking() / 10000.0;
}
itemRenderText.clear();
itemRenderText.setDoc(m_Doc);
itemRenderText.setDefaultStyle(itemText.defaultStyle());
for (a = firstChar; a < itemText.length(); ++a)
{
CharStyle nstyle = itemText.charStyle(a);
ParagraphStyle pstyle = itemText.paragraphStyle(a);
chstr = itemText.text(a, 1);
if ((chstr[0] == SpecialChars::OBJECT) && (itemText.hasObject(a)))
{
int pot = itemRenderText.length();
itemRenderText.insertObject(pot, itemText.object(a)->inlineCharID);
}
else
{
if (!(chstr[0] == SpecialChars::PARSEP || chstr[0] == SpecialChars::TAB || chstr[0] == SpecialChars::LINEBREAK))
chstr = ExpandToken(a);
for (int cc = 0; cc < chstr.count(); cc++)
{
int pot = itemRenderText.length();
itemRenderText.insertChars(pot, chstr.mid(cc, 1));
itemRenderText.applyStyle(pot, pstyle);
itemRenderText.applyCharStyle(pot, 1, nstyle);
}
}
chstr.clear();
}
textLayout.setStory(&itemRenderText);
int spaceCount = 0;
double wordExtra = 0;
for (a = firstChar; a < itemRenderText.length(); ++a)
{
GlyphLayout* glyphs = itemRenderText.getGlyphs(a);
chstr = itemRenderText.text(a, 1);
if (chstr[0] == SpecialChars::PAGENUMBER || chstr[0] == SpecialChars::PARSEP || chstr[0] == SpecialChars::PAGECOUNT
|| chstr[0] == SpecialChars::TAB || chstr[0] == SpecialChars::LINEBREAK)
continue;
if (chstr[0] == SpecialChars::BLANK)
spaceCount++;
if (a < itemRenderText.length()-1)
chstr += itemRenderText.text(a+1, 1);
glyphs->yadvance = 0;
layoutGlyphs(itemRenderText.charStyle(a), chstr, itemRenderText.flags(a), *glyphs);
glyphs->shrink();
if (itemRenderText.hasObject(a))
totalTextLen += (itemRenderText.object(a)->width() + itemRenderText.object(a)->lineWidth()) * glyphs->scaleH;
else
totalTextLen += glyphs->wide()+itemRenderText.charStyle(a).fontSize() * itemRenderText.charStyle(a).tracking() / 10000.0;
}
for (int segs = 0; segs < PoLine.size()-3; segs += 4)
{
totalCurveLen += PoLine.lenPathSeg(segs);
}
if ((itemRenderText.paragraphStyle(0).alignment() != 0) && (totalCurveLen >= totalTextLen + m_textDistanceMargins.left()))
{
if (itemRenderText.paragraphStyle(0).alignment() == 2)
{
CurX = totalCurveLen - totalTextLen;
CurX -= m_textDistanceMargins.left();
}
if (itemRenderText.paragraphStyle(0).alignment() == 1)
CurX = (totalCurveLen - totalTextLen) / 2.0;
if (itemRenderText.paragraphStyle(0).alignment() == 3)
{
if (spaceCount != 0)
{
extraOffset = 0;
wordExtra = (totalCurveLen - m_textDistanceMargins.left() - totalTextLen) / static_cast<double>(spaceCount);
}
else
{
extraOffset = (totalCurveLen - m_textDistanceMargins.left() - totalTextLen) / static_cast<double>(itemRenderText.length());
wordExtra = 0;
}
}
if (itemRenderText.paragraphStyle(0).alignment() == 4)
extraOffset = (totalCurveLen - m_textDistanceMargins.left() - totalTextLen) / static_cast<double>(itemRenderText.length());
}
QPainterPath guidePath = PoLine.toQPainterPath(false);
QList<QPainterPath> pathList = decomposePath(guidePath);
QPainterPath currPath = pathList[0];
int currPathIndex = 0;
for (a = firstChar; a < itemRenderText.length(); ++a)
{
CurY = 0;
GlyphLayout* glyphs = itemRenderText.getGlyphs(a);
PathData* pdata = & (textLayout.point(a));
chstr = itemRenderText.text(a,1);
if (chstr[0] == SpecialChars::PAGENUMBER || chstr[0] == SpecialChars::PARSEP || chstr[0] == SpecialChars::PAGECOUNT
|| chstr[0] == SpecialChars::TAB || chstr[0] == SpecialChars::LINEBREAK)
continue;
if (a < itemRenderText.length()-1)
chstr += itemRenderText.text(a+1, 1);
glyphs->yadvance = 0;
layoutGlyphs(itemRenderText.charStyle(a), chstr, itemRenderText.flags(a), *glyphs);
glyphs->shrink(); // HACK
if (itemRenderText.hasObject(a))
dx = (itemRenderText.object(a)->width() + itemRenderText.object(a)->lineWidth()) * glyphs->scaleH / 2.0;
else
dx = glyphs->wide() / 2.0;
CurX += dx;
double currPerc = currPath.percentAtLength(CurX);
if (currPerc >= 0.9999999)
{
currPathIndex++;
if (currPathIndex == pathList.count())
{
MaxChars = a;
break;
}
currPath = pathList[currPathIndex];
CurX = dx;
currPerc = currPath.percentAtLength(CurX);
}
double currAngle = currPath.angleAtPercent(currPerc);
if (currAngle <= 180.0)
currAngle *= -1.0;
else
currAngle = 360.0 - currAngle;
QPointF currPoint = currPath.pointAtPercent(currPerc);
tangent = FPoint(cos(currAngle * M_PI / 180.0), sin(currAngle * M_PI / 180.0));
point = FPoint(currPoint.x(), currPoint.y());
glyphs->xoffset = 0;
pdata->PtransX = point.x();
pdata->PtransY = point.y();
pdata->PRot = currAngle * M_PI / 180.0;
pdata->PDx = dx;
QTransform trafo = QTransform( 1, 0, 0, -1, -dx, 0 );
if (textPathFlipped)
trafo *= QTransform(1, 0, 0, -1, 0, 0);
if (textPathType == 0)
trafo *= QTransform( tangent.x(), tangent.y(), tangent.y(), -tangent.x(), point.x(), point.y() ); // ID's Rainbow mode
else if (textPathType == 1)
trafo *= QTransform( 1, 0, 0, -1, point.x(), point.y() ); // ID's Stair Step mode
else if (textPathType == 2)
{
double a = 1;
if (tangent.x() < 0)
a = -1;
if (fabs(tangent.x()) > 0.1)
trafo *= QTransform( a, (tangent.y() / tangent.x()) * a, 0, -1, point.x(), point.y() ); // ID's Skew mode
else
trafo *= QTransform( a, 4 * a, 0, -1, point.x(), point.y() );
}
QTransform sca = p->worldMatrix();
trafo *= sca;
p->save();
QTransform savWM = p->worldMatrix();
p->setWorldMatrix(trafo);
if (!m_Doc->RePos)
{
actFill = itemRenderText.charStyle(a).fillColor();
actFillShade = itemRenderText.charStyle(a).fillShade();
if (actFill != CommonStrings::None)
{
p->setFillMode(ScPainter::Solid);
if ((cachedFillShade != actFillShade) || (cachedFill != actFill))
{
SetQColor(&tmp, actFill, actFillShade);
p->setBrush(tmp);
cachedFillQ = tmp;
cachedFill = actFill;
cachedFillShade = actFillShade;
}
else
p->setBrush(cachedFillQ);
}
else
p->setFillMode(ScPainter::None);
actStroke = itemRenderText.charStyle(a).strokeColor();
actStrokeShade = itemRenderText.charStyle(a).strokeShade();
if (actStroke != CommonStrings::None)
{
if ((cachedStrokeShade != actStrokeShade) || (cachedStroke != actStroke))
{
SetQColor(&tmp, actStroke, actStrokeShade);
p->setPen(tmp, 1, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
cachedStrokeQ = tmp;
cachedStroke = actStroke;
cachedStrokeShade = actStrokeShade;
}
else
p->setPen(cachedStrokeQ, 1, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
}
p->translate(0.0, BaseOffs);
if (itemRenderText.hasObject(a))
DrawObj_Embedded(p, cullingArea, itemRenderText.charStyle(a), itemRenderText.object(a));
else
drawGlyphs(p, itemRenderText.charStyle(a), itemRenderText.flags(a), *glyphs);
}
p->setWorldMatrix(savWM);
p->restore();
MaxChars = a+1;
CurX -= dx;
if (itemRenderText.hasObject(a))
CurX += (itemRenderText.object(a)->width() + itemRenderText.object(a)->lineWidth()) * glyphs->scaleH + extraOffset;
else if (chstr[0] == SpecialChars::BLANK)
CurX += glyphs->wide()+itemRenderText.charStyle(a).fontSize() * itemRenderText.charStyle(a).tracking() / 10000.0 + wordExtra + extraOffset;
else
CurX += glyphs->wide()+itemRenderText.charStyle(a).fontSize() *itemRenderText.charStyle(a).tracking() / 10000.0 + extraOffset;
}
}
void PageItem_PathText::DrawObj_Item(ScPainter *p, QRectF cullingArea)
{
itemText.invalidateAll();
firstChar = 0;
MaxChars = 0;
int a;
double chs;
QString chstr, chstr2, chstr3;
ScText *hl;
double dx;
FPoint point = FPoint(0, 0);
FPoint tangent = FPoint(0, 0);
uint seg = 0;
double segLen = 0;
QColor tmp;
CurX = Extra;
QString cachedStroke = "";
QString cachedFill = "";
double cachedFillShade = -1;
double cachedStrokeShade = -1;
QString actStroke = "";
QString actFill = "";
double actFillShade = -1;
double actStrokeShade = -1;
QColor cachedFillQ;
QColor cachedStrokeQ;
if (!m_Doc->layerOutline(LayerID))
{
if (PoShow)
{
p->setupPolygon(&PoLine, false);
if (NamedLStyle.isEmpty())
{
if ((!patternStrokeVal.isEmpty()) && (m_Doc->docPatterns.contains(patternStrokeVal)))
{
if (patternStrokePath)
{
QPainterPath guidePath = PoLine.toQPainterPath(false);
DrawStrokePattern(p, guidePath);
}
else
{
p->setPattern(&m_Doc->docPatterns[patternStrokeVal], patternStrokeScaleX, patternStrokeScaleY, patternStrokeOffsetX, patternStrokeOffsetY, patternStrokeRotation, patternStrokeSkewX, patternStrokeSkewY, patternStrokeMirrorX, patternStrokeMirrorY);
p->setStrokeMode(ScPainter::Pattern);
p->strokePath();
}
}
else if (GrTypeStroke > 0)
{
if ((!gradientStrokeVal.isEmpty()) && (!m_Doc->docGradients.contains(gradientStrokeVal)))
gradientStrokeVal = "";
if (!(gradientStrokeVal.isEmpty()) && (m_Doc->docGradients.contains(gradientStrokeVal)))
stroke_gradient = m_Doc->docGradients[gradientStrokeVal];
if (stroke_gradient.Stops() < 2) // fall back to solid stroking if there are not enough colorstops in the gradient.
{
if (lineColor() != CommonStrings::None)
{
p->setBrush(strokeQColor);
p->setStrokeMode(ScPainter::Solid);
}
else
p->setStrokeMode(ScPainter::None);
}
else
{
p->setStrokeMode(ScPainter::Gradient);
p->stroke_gradient = stroke_gradient;
if (GrTypeStroke == 6)
p->setGradient(VGradient::linear, FPoint(GrStrokeStartX, GrStrokeStartY), FPoint(GrStrokeEndX, GrStrokeEndY), FPoint(GrStrokeStartX, GrStrokeStartY), GrStrokeScale, GrStrokeSkew);
else
p->setGradient(VGradient::radial, FPoint(GrStrokeStartX, GrStrokeStartY), FPoint(GrStrokeEndX, GrStrokeEndY), FPoint(GrStrokeFocalX, GrStrokeFocalY), GrStrokeScale, GrStrokeSkew);
}
p->strokePath();
}
else if (lineColor() != CommonStrings::None)
{
p->setStrokeMode(ScPainter::Solid);
p->strokePath();
}
}
else
{
p->setStrokeMode(ScPainter::Solid);
multiLine ml = m_Doc->MLineStyles[NamedLStyle];
QColor tmp;
for (int it = ml.size()-1; it > -1; it--)
{
if (ml[it].Color != CommonStrings::None) // && (ml[it].Width != 0))
{
SetQColor(&tmp, ml[it].Color, ml[it].Shade);
p->setPen(tmp, ml[it].Width, static_cast<Qt::PenStyle>(ml[it].Dash), static_cast<Qt::PenCapStyle>(ml[it].LineEnd), static_cast<Qt::PenJoinStyle>(ml[it].LineJoin));
p->strokePath();
}
}
}
}
}
double totalTextLen = 0.0;
double totalCurveLen = 0.0;
double extraOffset = 0.0;
if (itemText.length() != 0)
{
CurX += itemText.charStyle(0).fontSize() * itemText.charStyle(0).tracking() / 10000.0;
totalTextLen += itemText.charStyle(0).fontSize() * itemText.charStyle(0).tracking() / 10000.0;
}
segLen = PoLine.lenPathSeg(seg);
for (a = firstChar; a < itemText.length(); ++a)
{
hl = itemText.item(a);
chstr = hl->ch;
if (chstr[0] == SpecialChars::PAGENUMBER || chstr[0] == SpecialChars::PARSEP || chstr[0] == SpecialChars::PAGECOUNT
|| chstr[0] == SpecialChars::TAB || chstr[0] == SpecialChars::LINEBREAK)
continue;
if (a < itemText.length()-1)
chstr += itemText.text(a+1, 1);
hl->glyph.yadvance = 0;
layoutGlyphs(itemText.charStyle(a), chstr, hl->glyph);
hl->glyph.shrink();
if (hl->ch == SpecialChars::OBJECT)
totalTextLen += (hl->embedded.getItem()->gWidth + hl->embedded.getItem()->lineWidth()) * hl->glyph.scaleH;
else
totalTextLen += hl->glyph.wide()+hl->fontSize() * hl->tracking() / 10000.0;
}
for (uint segs = 0; segs < PoLine.size()-3; segs += 4)
{
totalCurveLen += PoLine.lenPathSeg(segs);
}
if ((itemText.defaultStyle().alignment() != 0) && (totalCurveLen >= totalTextLen + Extra))
{
if (itemText.defaultStyle().alignment() == 2)
{
CurX = totalCurveLen - totalTextLen;
CurX -= Extra;
}
if (itemText.defaultStyle().alignment() == 1)
CurX = (totalCurveLen - totalTextLen) / 2.0;
if ((itemText.defaultStyle().alignment() == 3) || (itemText.defaultStyle().alignment() == 4))
extraOffset = (totalCurveLen - Extra - totalTextLen) / static_cast<double>(itemText.length());
}
#ifndef NLS_PROTO
QPainterPath guidePath = PoLine.toQPainterPath(false);
QList<QPainterPath> pathList = decomposePath(guidePath);
QPainterPath currPath = pathList[0];
int currPathIndex = 0;
for (a = firstChar; a < itemText.length(); ++a)
{
CurY = 0;
hl = itemText.item(a);
chstr = hl->ch;
if (chstr[0] == SpecialChars::PAGENUMBER || chstr[0] == SpecialChars::PARSEP || chstr[0] == SpecialChars::PAGECOUNT
|| chstr[0] == SpecialChars::TAB || chstr[0] == SpecialChars::LINEBREAK)
continue;
chs = hl->fontSize();
if (a < itemText.length()-1)
chstr += itemText.text(a+1, 1);
hl->glyph.yadvance = 0;
layoutGlyphs(itemText.charStyle(a), chstr, hl->glyph);
hl->glyph.shrink(); // HACK
if (hl->ch == SpecialChars::OBJECT)
dx = (hl->embedded.getItem()->gWidth + hl->embedded.getItem()->lineWidth()) * hl->glyph.scaleH / 2.0;
else
dx = hl->glyph.wide() / 2.0;
CurX += dx;
double currPerc = currPath.percentAtLength(CurX);
if (currPerc >= 0.9999999)
{
currPathIndex++;
if (currPathIndex == pathList.count())
{
MaxChars = a;
break;
}
currPath = pathList[currPathIndex];
CurX = dx;
currPerc = currPath.percentAtLength(CurX);
}
double currAngle = currPath.angleAtPercent(currPerc);
#if QT_VERSION >= 0x040400
if (currAngle <= 180.0)
currAngle *= -1.0;
else
currAngle = 360.0 - currAngle;
#endif
QPointF currPoint = currPath.pointAtPercent(currPerc);
tangent = FPoint(cos(currAngle * M_PI / 180.0), sin(currAngle * M_PI / 180.0));
point = FPoint(currPoint.x(), currPoint.y());
hl->glyph.xoffset = 0;
hl->PtransX = point.x();
hl->PtransY = point.y();
hl->PRot = currAngle * M_PI / 180.0;
hl->PDx = dx;
QTransform trafo = QTransform( 1, 0, 0, -1, -dx, 0 );
if (textPathFlipped)
trafo *= QTransform(1, 0, 0, -1, 0, 0);
if (textPathType == 0)
trafo *= QTransform( tangent.x(), tangent.y(), tangent.y(), -tangent.x(), point.x(), point.y() ); // ID's Rainbow mode
else if (textPathType == 1)
trafo *= QTransform( 1, 0, 0, -1, point.x(), point.y() ); // ID's Stair Step mode
else if (textPathType == 2)
{
double a = 1;
if (tangent.x() < 0)
a = -1;
if (fabs(tangent.x()) > 0.1)
trafo *= QTransform( a, (tangent.y() / tangent.x()) * a, 0, -1, point.x(), point.y() ); // ID's Skew mode
else
trafo *= QTransform( a, 4 * a, 0, -1, point.x(), point.y() );
}
QTransform sca = p->worldMatrix();
trafo *= sca;
p->save();
QTransform savWM = p->worldMatrix();
p->setWorldMatrix(trafo);
if (!m_Doc->RePos)
{
actFill = itemText.charStyle(a).fillColor();
actFillShade = itemText.charStyle(a).fillShade();
if (actFill != CommonStrings::None)
{
p->setFillMode(ScPainter::Solid);
if ((cachedFillShade != actFillShade) || (cachedFill != actFill))
{
SetQColor(&tmp, actFill, actFillShade);
p->setBrush(tmp);
cachedFillQ = tmp;
cachedFill = actFill;
cachedFillShade = actFillShade;
}
else
p->setBrush(cachedFillQ);
}
else
p->setFillMode(ScPainter::None);
actStroke = itemText.charStyle(a).strokeColor();
actStrokeShade = itemText.charStyle(a).strokeShade();
if (actStroke != CommonStrings::None)
{
if ((cachedStrokeShade != actStrokeShade) || (cachedStroke != actStroke))
{
SetQColor(&tmp, actStroke, actStrokeShade);
p->setPen(tmp, 1, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
cachedStrokeQ = tmp;
cachedStroke = actStroke;
cachedStrokeShade = actStrokeShade;
}
else
p->setPen(cachedStrokeQ, 1, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
}
p->translate(0.0, BaseOffs);
if (hl->ch == SpecialChars::OBJECT)
DrawObj_Embedded(p, cullingArea, itemText.charStyle(a), hl->embedded.getItem());
else
drawGlyphs(p, itemText.charStyle(a), hl->glyph);
}
p->setWorldMatrix(savWM);
p->restore();
MaxChars = a+1;
CurX -= dx;
if (hl->ch == SpecialChars::OBJECT)
CurX += (hl->embedded.getItem()->gWidth + hl->embedded.getItem()->lineWidth()) * hl->glyph.scaleH;
else
CurX += hl->glyph.wide()+hl->fontSize() * hl->tracking() / 10000.0 + extraOffset;
}
#endif
}
void BezierMode::mousePressEvent(QMouseEvent *m)
{
const FPoint mousePointDoc = m_canvas->globalToCanvas(m->globalPos());
int z;
double Rxp = 0;
double Ryp = 0;
double Rxpd = 0;
double Rypd = 0;
PageItem *currItem;
// m_canvas->PaintSizeRect(QRect());
FPoint npf, npf2;
QRect tx;
QTransform pm;
m_MouseButtonPressed = true;
m_view->HaveSelRect = false;
m_doc->DragP = false;
m_doc->leaveDrag = false;
MoveGX = MoveGY = false;
// inItemCreation = false;
// oldClip = 0;
m->accept();
m_view->registerMousePress(m->globalPos());
Mxp = mousePointDoc.x(); //qRound(m->x()/m_canvas->scale() + 0*m_doc->minCanvasCoordinate.x());
Myp = mousePointDoc.y(); //qRound(m->y()/m_canvas->scale() + 0*m_doc->minCanvasCoordinate.y());
QRect mpo(m->x()-m_doc->guidesPrefs().grabRadius, m->y()-m_doc->guidesPrefs().grabRadius, m_doc->guidesPrefs().grabRadius*2, m_doc->guidesPrefs().grabRadius*2);
// mpo.moveBy(qRound(m_doc->minCanvasCoordinate.x() * m_canvas->scale()), qRound(m_doc->minCanvasCoordinate.y() * m_canvas->scale()));
Rxp = m_doc->ApplyGridF(FPoint(Mxp, Myp)).x();
Rxpd = Mxp - Rxp;
Mxp = qRound(Rxp);
Ryp = m_doc->ApplyGridF(FPoint(Mxp, Myp)).y();
Rypd = Myp - Ryp;
Myp = qRound(Ryp);
SeRx = Mxp;
SeRy = Myp;
if (m->button() == Qt::MidButton)
{
m_view->MidButt = true;
if (m->modifiers() & Qt::ControlModifier)
m_view->DrawNew();
return;
}
if (m->button() == Qt::RightButton)
{
m_view->stopGesture();
return;
}
if (FirstPoly)
{
selectPage(m);
undoManager->setUndoEnabled(false);
z = m_doc->itemAdd(PageItem::PolyLine, PageItem::Unspecified, Rxp, Ryp, 1+Rxpd, 1+Rypd, m_doc->itemToolPrefs().lineWidth, CommonStrings::None, m_doc->itemToolPrefs().lineColor);
currItem = m_doc->Items->at(z);
m_doc->m_Selection->clear();
m_doc->m_Selection->addItem(currItem);
m_view->setCursor(QCursor(Qt::CrossCursor));
m_canvas->setRenderModeFillBuffer();
inItemCreation = true;
}
currItem = m_doc->m_Selection->itemAt(0);
// pm.translate(-m_doc->minCanvasCoordinate.x()*m_canvas->scale(), -m_doc->minCanvasCoordinate.y()*m_canvas->scale());
pm = currItem->getTransform();
npf = m_doc->ApplyGridF(mousePointDoc).transformPoint(pm, true);
currItem->PoLine.addPoint(npf);
npf2 = getMinClipF(&currItem->PoLine);
if (npf2.x() < 0)
{
currItem->PoLine.translate(-npf2.x(), 0);
m_doc->MoveItem(npf2.x(), 0, currItem);
}
if (npf2.y() < 0)
{
currItem->PoLine.translate(0, -npf2.y());
m_doc->MoveItem(0, npf2.y(), currItem);
}
m_doc->SizeItem(currItem->PoLine.WidthHeight().x(), currItem->PoLine.WidthHeight().y(), currItem, false, false, false);
currItem->setPolyClip(qRound(qMax(currItem->lineWidth() / 2, 1.0)));
m_canvas->newRedrawPolygon();
undoManager->setUndoEnabled(false);
}
void PageItem_PolyLine::DrawObj_Item(ScPainter *p, QRectF /*e*/, double /*sc*/)
{
if (!m_Doc->RePos && PoLine.size()>=4)
{
if (!m_Doc->layerOutline(LayerNr))
{
if ((fillColor() != CommonStrings::None) || (GrType != 0))
{
FPointArray cli;
FPoint Start;
bool firstp = true;
for (uint n = 0; n < PoLine.size()-3; n += 4)
{
if (firstp)
{
Start = PoLine.point(n);
firstp = false;
}
if (PoLine.point(n).x() > 900000)
{
cli.addPoint(PoLine.point(n-2));
cli.addPoint(PoLine.point(n-2));
cli.addPoint(Start);
cli.addPoint(Start);
cli.setMarker();
firstp = true;
continue;
}
cli.addPoint(PoLine.point(n));
cli.addPoint(PoLine.point(n+1));
cli.addPoint(PoLine.point(n+2));
cli.addPoint(PoLine.point(n+3));
}
if (cli.size() > 2)
{
FPoint l1 = cli.point(cli.size()-2);
cli.addPoint(l1);
cli.addPoint(l1);
cli.addPoint(Start);
cli.addPoint(Start);
}
p->setupPolygon(&cli);
p->fillPath();
}
p->setupPolygon(&PoLine, false);
if (NamedLStyle.isEmpty())
{
if (lineColor() != CommonStrings::None)
p->strokePath();
}
else
{
multiLine ml = m_Doc->MLineStyles[NamedLStyle];
QColor tmp;
for (int it = ml.size()-1; it > -1; it--)
{
if (ml[it].Color != CommonStrings::None) // && (ml[it].Width != 0))
{
SetQColor(&tmp, ml[it].Color, ml[it].Shade);
p->setPen(tmp, ml[it].Width, static_cast<Qt::PenStyle>(ml[it].Dash), static_cast<Qt::PenCapStyle>(ml[it].LineEnd), static_cast<Qt::PenJoinStyle>(ml[it].LineJoin));
p->strokePath();
}
}
}
}
if (m_startArrowIndex != 0)
{
FPoint Start = PoLine.point(0);
for (uint xx = 1; xx < PoLine.size(); xx += 2)
{
FPoint Vector = PoLine.point(xx);
if ((Start.x() != Vector.x()) || (Start.y() != Vector.y()))
{
double r = atan2(Start.y()-Vector.y(),Start.x()-Vector.x())*(180.0/M_PI);
QMatrix arrowTrans;
arrowTrans.translate(Start.x(), Start.y());
arrowTrans.rotate(r);
drawArrow(p, arrowTrans, m_startArrowIndex);
break;
}
}
}
if (m_endArrowIndex != 0)
{
FPoint End = PoLine.point(PoLine.size()-2);
for (uint xx = PoLine.size()-1; xx > 0; xx -= 2)
{
FPoint Vector = PoLine.point(xx);
if ((End.x() != Vector.x()) || (End.y() != Vector.y()))
{
double r = atan2(End.y()-Vector.y(),End.x()-Vector.x())*(180.0/M_PI);
QMatrix arrowTrans;
arrowTrans.translate(End.x(), End.y());
arrowTrans.rotate(r);
drawArrow(p, arrowTrans, m_endArrowIndex);
break;
}
}
}
}
}
void CanvasMode_EditPolygon::mousePressEvent(QMouseEvent *m)
{
const FPoint mousePointDoc = m_canvas->globalToCanvas(m->globalPos());
m_canvas->PaintSizeRect(QRect());
m_canvas->m_viewMode.m_MouseButtonPressed = true;
m_canvas->m_viewMode.operItemMoving = false;
m_view->HaveSelRect = false;
m_doc->DragP = false;
m_doc->leaveDrag = false;
m->accept();
m_view->registerMousePress(m->globalPos());
Mxp = mousePointDoc.x(); //m->x();
Myp = mousePointDoc.y(); //m->y();
if (m->button() == Qt::MidButton)
{
m_view->MidButt = true;
if (m->modifiers() & Qt::ControlModifier)
m_view->DrawNew();
return;
}
PageItem *currItem = m_doc->m_Selection->itemAt(0);
QTransform itemMatrix = currItem->getTransform();
QPointF stPoint = startPoint;
stPoint = itemMatrix.map(stPoint);
QPointF swPoint = endPoint;
swPoint = itemMatrix.map(swPoint);
QPointF shPoint = innerCPoint;
shPoint = itemMatrix.map(shPoint);
QPointF sPoint = outerCPoint;
sPoint = itemMatrix.map(sPoint);
bool useOuter = m_canvas->hitsCanvasPoint(m->globalPos(), stPoint);
bool useInner = m_canvas->hitsCanvasPoint(m->globalPos(), swPoint);
bool useInnerC = m_canvas->hitsCanvasPoint(m->globalPos(), shPoint);
bool useOuterC = m_canvas->hitsCanvasPoint(m->globalPos(), sPoint);
if (useOuter && useOuterC)
{
if (m->modifiers() == Qt::ShiftModifier)
m_polygonPoint = useControlOuterCurve;
else
m_polygonPoint = useControlOuter;
}
else if (useOuter || useOuterC)
{
if (useOuterC)
m_polygonPoint = useControlOuterCurve;
else
m_polygonPoint = useControlOuter;
}
else if (useInner && useInnerC)
{
if (m->modifiers() == Qt::ShiftModifier)
m_polygonPoint = useControlInnerCurve;
else
m_polygonPoint = useControlInner;
}
else if (useInner || useInnerC)
{
if (useInnerC)
m_polygonPoint = useControlInnerCurve;
else
m_polygonPoint = useControlInner;
}
else
m_polygonPoint = noPointDefined;
if (m_polygonPoint != noPointDefined && UndoManager::undoEnabled())
m_transaction = undoManager->beginTransaction(Um::Polygon, Um::IPolygon, Um::EditPolygon, "", Um::IPolygon);
m_view->setCursor(QCursor(Qt::CrossCursor));
QPainterPath path = itemMatrix.map(RegularPolygonPath(currItem->width(), currItem->height(), polyCorners, polyUseFactor, polyFactor, polyRotation, polyCurvature, polyInnerRot, polyOuterCurvature));
m_doc->regionsChanged()->update(path.boundingRect().adjusted(-5, -5, 10, 10));
}
void CanvasMode_EditMeshGradient::mouseMoveEvent(QMouseEvent *m)
{
const FPoint mousePointDoc = m_canvas->globalToCanvas(m->globalPos());
m->accept();
if (m_selectedMeshPoints.count() == 0)
return;
if (m_canvas->m_viewMode.m_MouseButtonPressed && m_view->moveTimerElapsed())
{
FPoint npfN;
double nx = mousePointDoc.x();
double ny = mousePointDoc.y();
if (!m_doc->ApplyGuides(&nx, &ny) && !m_doc->ApplyGuides(&nx, &ny,true))
npfN = m_doc->ApplyGridF(FPoint(nx, ny));
else
npfN = FPoint(nx, ny);
PageItem *currItem = m_doc->m_Selection->itemAt(0);
QTransform pp = currItem->getTransform();
FPoint npf = npfN.transformPoint(pp, true);
if (m_view->editStrokeGradient == 6)
{
if (m_selectedMeshPoints.count() > 0)
{
QPair<int, int> selP = m_selectedMeshPoints[0];
FPoint cP = currItem->meshGradientArray[selP.first][selP.second].controlColor;
FPoint gP = currItem->meshGradientArray[selP.first][selP.second].gridPoint;
m_canvas->displayXYHUD(m->globalPos(), cP.x() - gP.x(), cP.y() - gP.y());
}
}
else
m_canvas->displayXYHUD(m->globalPos(), npf.x(), npf.y());
FPoint npx(m_Mxp - npfN.x(), m_Myp - npfN.y(), 0, 0, currItem->rotation(), 1, 1, true);
if (m_selectedMeshPoints.count() > 0)
{
if (m_view->editStrokeGradient == 5)
{
for (int mo = 0; mo < m_selectedMeshPoints.count(); mo++)
{
QPair<int, int> selP = m_selectedMeshPoints[mo];
currItem->meshGradientArray[selP.first][selP.second].moveRel(-npx.x(), -npx.y());
}
}
else if (m_view->editStrokeGradient == 6)
{
QPair<int, int> selP = m_selectedMeshPoints[0];
currItem->meshGradientArray[selP.first][selP.second].controlColor -= npx;
}
else if (m_view->editStrokeGradient == 7)
{
QPair<int, int> selP = m_selectedMeshPoints[0];
if (m_gradientPoint == useControlT)
currItem->meshGradientArray[selP.first][selP.second].controlTop -= npx;
else if (m_gradientPoint == useControlB)
currItem->meshGradientArray[selP.first][selP.second].controlBottom -= npx;
else if (m_gradientPoint == useControlL)
currItem->meshGradientArray[selP.first][selP.second].controlLeft -= npx;
else if (m_gradientPoint == useControlR)
currItem->meshGradientArray[selP.first][selP.second].controlRight -= npx;
}
currItem->update();
QTransform itemMatrix = currItem->getTransform();
m_doc->regionsChanged()->update(itemMatrix.mapRect(QRectF(0, 0, currItem->width(), currItem->height())).adjusted(-currItem->width() / 2.0, -currItem->height() / 2.0, currItem->width(), currItem->height()));
}
m_Mxp = npfN.x();
m_Myp = npfN.y();
}
}
void PropertiesPalette_XYZ::displayXY(double x, double y)
{
if (!m_ScMW || m_ScMW->scriptIsRunning())
return;
disconnect(xposSpin, SIGNAL(valueChanged(double)), this, SLOT(handleNewX()));
disconnect(yposSpin, SIGNAL(valueChanged(double)), this, SLOT(handleNewY()));
bool useLineMode = false;
bool tmp = m_haveItem;
double inX, inY, b, h, r, dummy1, dummy2;
QTransform ma;
FPoint n;
if (m_haveItem)
{
if (m_doc->m_Selection->isMultipleSelection())
{
m_doc->m_Selection->getGroupRect(&dummy1, &dummy2, &b, &h);
r = 0.0;
ma.translate(dummy1, dummy2);
}
else
{
b = m_item->width();
h = m_item->height();
r = m_item->rotation();
ma.translate(x, y);
useLineMode = (m_lineMode && m_item->isLine());
}
}
else
{
b = 0.0;
h = 0.0;
r = 0.0;
ma.translate(x, y);
}
m_haveItem = false;
ma.rotate(r);
int bp = basePointWidget->checkedId();
// #8890 : basepoint is meaningless when lines use "end points" mode
if (bp == 0 || useLineMode)
n = FPoint(0.0, 0.0);
else if (bp == 1)
n = FPoint(b, 0.0);
else if (bp == 2)
n = FPoint(b / 2.0, h / 2.0);
else if (bp == 3)
n = FPoint(0.0, h);
else if (bp == 4)
n = FPoint(b, h);
inX = ma.m11() * n.x() + ma.m21() * n.y() + ma.dx();
inY = ma.m22() * n.y() + ma.m12() * n.x() + ma.dy();
if (tmp)
{
inX -= m_doc->rulerXoffset;
inY -= m_doc->rulerYoffset;
if (m_doc->guidesPrefs().rulerMode)
{
inX -= m_doc->currentPage()->xOffset();
inY -= m_doc->currentPage()->yOffset();
}
}
xposSpin->setValue(inX*m_unitRatio);
yposSpin->setValue(inY*m_unitRatio);
if (useLineMode)
displayWH(m_item->width(), m_item->height());
m_haveItem = tmp;
connect(xposSpin, SIGNAL(valueChanged(double)), this, SLOT(handleNewX()));
connect(yposSpin, SIGNAL(valueChanged(double)), this, SLOT(handleNewY()));
}
void PropertiesPalette_XYZ::handleBasePoint(int m)
{
if (!m_ScMW || m_ScMW->scriptIsRunning())
return;
double inX, inY, gx, gy, gh, gw;
inX = 0;
inY = 0;
if ((m_haveDoc) && (m_haveItem))
{
m_haveItem = false;
m_doc->RotMode ( m );
if (m_doc->m_Selection->isMultipleSelection())
{
m_doc->m_Selection->setGroupRect();
m_doc->m_Selection->getGroupRect(&gx, &gy, &gw, &gh);
if (m == 0)
{
m_ScMW->view->RCenter = FPoint(gx, gy);
inX = gx;
inY = gy;
}
if (m == 1)
{
m_ScMW->view->RCenter = FPoint(gx+gw, gy);
inX = gx+gw;
inY = gy;
}
if (m == 2)
{
m_ScMW->view->RCenter = FPoint(gx + gw / 2.0, gy + gh / 2.0);
inX = gx + gw / 2.0;
inY = gy + gh / 2.0;
}
if (m == 3)
{
m_ScMW->view->RCenter = FPoint(gx, gy+gh);
inX = gx;
inY = gy+gh;
}
if (m == 4)
{
m_ScMW->view->RCenter = FPoint(gx+gw, gy+gh);
inX = gx+gw;
inY = gy+gh;
}
inX -= m_doc->rulerXoffset;
inY -= m_doc->rulerYoffset;
if (m_doc->guidesPrefs().rulerMode)
{
inX -= m_doc->currentPage()->xOffset();
inY -= m_doc->currentPage()->yOffset();
}
xposSpin->setValue(inX*m_unitRatio);
yposSpin->setValue(inY*m_unitRatio);
}
else
{
double b, h, r;
QTransform ma;
FPoint n;
b = m_item->width();
h = m_item->height();
r = m_item->rotation();
ma.translate(m_item->xPos(), m_item->yPos());
ma.rotate(r);
int bp = basePointWidget->checkedId();
if (bp == 0)
n = FPoint(0.0, 0.0);
else if (bp == 1)
n = FPoint(b, 0.0);
else if (bp == 2)
n = FPoint(b / 2.0, h / 2.0);
else if (bp == 3)
n = FPoint(0.0, h);
else if (bp == 4)
n = FPoint(b, h);
inX = ma.m11() * n.x() + ma.m21() * n.y() + ma.dx();
inY = ma.m22() * n.y() + ma.m12() * n.x() + ma.dy();
inX -= m_doc->rulerXoffset;
inY -= m_doc->rulerYoffset;
if (m_doc->guidesPrefs().rulerMode)
{
inX -= m_doc->currentPage()->xOffset();
inY -= m_doc->currentPage()->yOffset();
}
xposSpin->setValue(inX*m_unitRatio);
yposSpin->setValue(inY*m_unitRatio);
}
if (m_item->itemType() == PageItem::ImageFrame)
{
// FIXME
if (false /*!FreeScale->isChecked()*/)
{
m_item->AdjustPictScale();
m_item->update();
emit DocChanged();
}
}
m_haveItem = true;
}
}
double getCurveYValue(FPointArray &curve, double x, bool linear)
{
double t;
FPoint p;
FPoint p0,p1,p2,p3;
double c0,c1,c2,c3;
double val = 0.5;
if(curve.size() == 0)
return 0.5;
// First find curve segment
p = curve.point(0);
if(x < p.x())
return p.y();
p = curve.point(curve.size()-1);
if(x >= p.x())
return p.y();
uint cc = 0;
// Find the four control points (two on each side of x)
p = curve.point(0);
while(x >= p.x())
{
cc++;
p = curve.point(cc);
}
if (cc > 1)
{
p0 = curve.point(cc-2);
p1 = curve.point(cc-1);
}
else
p1 = p0 = curve.point(0);
p2 = p;
if (cc < curve.size()-1)
p3 = curve.point(cc+1);
else
p3 = p;
// Calculate the value
if (linear)
{
double mc;
if (p1.x() - p2.x() != 0.0)
mc = (p1.y() - p2.y()) / (p1.x() - p2.x());
else
mc = p2.y() / p2.x();
val = (x - p1.x()) * mc + p1.y();
}
else
{
t = (x - p1.x()) / (p2.x() - p1.x());
c2 = (p2.y() - p0.y()) * (p2.x()-p1.x()) / (p2.x()-p0.x());
c3 = p1.y();
c0 = -2*p2.y() + 2*c3 + c2 + (p3.y() - p1.y()) * (p2.x() - p1.x()) / (p3.x() - p1.x());
c1 = p2.y() - c3 - c2 - c0;
val = ((c0*t + c1)*t + c2)*t + c3;
}
if(val < 0.0)
val = 0.0;
if(val > 1.0)
val = 1.0;
return val;
}
void CanvasMode_EditPolygon::mouseMoveEvent(QMouseEvent *m)
{
const FPoint mousePointDoc = m_canvas->globalToCanvas(m->globalPos());
m->accept();
double newX = mousePointDoc.x();
double newY = mousePointDoc.y();
if (m_canvas->m_viewMode.m_MouseButtonPressed && m_view->moveTimerElapsed())
{
PageItem *currItem = m_doc->m_Selection->itemAt(0);
QTransform itemMatrix = currItem->getTransform();
QPointF cPoint = itemMatrix.map(centerPoint);
QLineF stLinA = QLineF(cPoint, QPointF(newX, newY));
uint cx = polyUseFactor ? polyCorners * 2 : polyCorners;
double seg = 360.0 / cx;
double trueLength = sqrt(pow(sin(seg / 180.0 * M_PI) * (currItem->width() / 2.0), 2) + pow(cos(seg / 180.0 * M_PI) * (currItem->height() / 2.0) + (currItem->height()/2.0) - currItem->height(), 2));
if (m_polygonPoint == useControlInner)
{
polyInnerRot = stLinA.angle() - 90 - polyRotation - seg;
double factor = stLinA.length() / sqrt(pow(sin(stLinA.angle() * M_PI / 180.0) * currItem->height() / 2.0, 2) + pow(cos(stLinA.angle() * M_PI / 180.0) * currItem->width() / 2.0, 2));
int maxF = qRound(getUserValFromFactor(factor));
if (maxF <= 100)
polyFactor = factor;
}
if (m_polygonPoint == useControlOuter)
{
polyRotation = stLinA.angle() - 90;
if (polyRotation < -180)
polyRotation += 360;
if (polyRotation > 180)
polyRotation -= 360;
}
if (m_polygonPoint == useControlInnerCurve)
{
QPointF ePoint = itemMatrix.map(endPoint);
QLineF stLinC = QLineF(ePoint, QPointF(newX, newY));
polyCurvature = stLinC.length() / trueLength;
}
if (m_polygonPoint == useControlOuterCurve)
{
QPointF sPoint = itemMatrix.map(startPoint);
QPointF sPoint2 = itemMatrix.map(currItem->PoLine.pointQF(6));
QLineF stLinCo = QLineF(sPoint, QPointF(newX, newY));
QLineF stLinCo2 = QLineF(sPoint, sPoint2);
polyOuterCurvature = stLinCo.length() / stLinCo2.length();
}
QPainterPath path = RegularPolygonPath(currItem->width(), currItem->height(), polyCorners, polyUseFactor, polyFactor, polyRotation, polyCurvature, polyInnerRot, polyOuterCurvature);
FPointArray ar;
ar.fromQPainterPath(path);
endPoint = ar.pointQF(2);
startPoint = ar.pointQF(0);
QLineF innerLine = QLineF(endPoint, centerPoint);
innerLine.setAngle(innerLine.angle() + 90);
innerLine.setLength(trueLength * polyCurvature);
innerCPoint = innerLine.p2();
QLineF outerLine = QLineF(startPoint, ar.pointQF(6));
outerLine.setLength(outerLine.length() * polyOuterCurvature);
outerCPoint = outerLine.p2();
VectorDialog->setValues(polyCorners, polyFactor, polyUseFactor, polyRotation, polyCurvature, polyInnerRot, polyOuterCurvature);
blockUpdateFromItem(true);
currItem->update();
blockUpdateFromItem(false);
path = itemMatrix.map(path);
m_doc->regionsChanged()->update(path.boundingRect().adjusted(-5, -5, 10, 10));
}
Mxp = newX;
Myp = newY;
}
void BezierMode::mouseMoveEvent(QMouseEvent *m)
{
const FPoint mousePointDoc = m_canvas->globalToCanvas(m->globalPos());
double newX, newY;
PageItem *currItem;
QPoint np, np2, mop;
FPoint npf, npf2;
QRect tx;
m->accept();
m_canvas->displayCorrectedXYHUD(m->globalPos(), mousePointDoc.x(), mousePointDoc.y());
// qDebug() << "legacy mode move:" << m->x() << m->y() << m_canvas->globalToCanvas(m->globalPos()).x() << m_canvas->globalToCanvas(m->globalPos()).y();
// emit MousePos(m->x()/m_canvas->scale(),// + m_doc->minCanvasCoordinate.x(),
// m->y()/m_canvas->scale()); // + m_doc->minCanvasCoordinate.y());
/* if (m_doc->guidesPrefs().guidesShown)
{
if (MoveGY)
{
m_view->FromHRuler(m);
return;
}
if (MoveGX)
{
m_view->FromVRuler(m);
return;
}
}
*/
if (commonMouseMove(m))
return;
if (inItemCreation)
{
if ((GetItem(&currItem)) && (!shiftSelItems))
{
newX = qRound(mousePointDoc.x()); //m_view->translateToDoc(m->x(), m->y()).x());
newY = qRound(mousePointDoc.y()); //m_view->translateToDoc(m->x(), m->y()).y());
if (m_doc->DragP)
return;
if (m_doc->appMode == modeDrawBezierLine)
{
if ((m_doc->SnapGrid) && (m_doc->OnPage(currItem) != -1))
{
newX = qRound(newX / m_doc->guidesPrefs().minorGridSpacing) * m_doc->guidesPrefs().minorGridSpacing;
newY = qRound(newY / m_doc->guidesPrefs().minorGridSpacing) * m_doc->guidesPrefs().minorGridSpacing;
}
m_canvas->newRedrawPolygon() << QPoint(qRound(newX - currItem->xPos()), qRound(newY - currItem->yPos()));
m_view->updateCanvas();
Mxp = newX;
Myp = newY;
}
}
else
{
if ((m_MouseButtonPressed) && (m->buttons() & Qt::LeftButton))
{
newX = qRound(mousePointDoc.x()); //m_view->translateToDoc(m->x(), m->y()).x());
newY = qRound(mousePointDoc.y()); //m_view->translateToDoc(m->x(), m->y()).y());
SeRx = newX;
SeRy = newY;
QPoint startP = m_canvas->canvasToGlobal(QPointF(Mxp, Myp));
m_view->redrawMarker->setGeometry(QRect(m_view->mapFromGlobal(startP), m_view->mapFromGlobal(m->globalPos())).normalized());
m_view->setRedrawMarkerShown(true);
m_view->HaveSelRect = true;
return;
}
}
}
}
void CreateMode::mouseMoveEvent(QMouseEvent *m)
{
const FPoint mousePointDoc = m_canvas->globalToCanvas(m->globalPos());
modifiers = m->modifiers();
double newX, newY;
PageItem *currItem;
QPoint np, np2, mop;
QPainter p;
QRect tx;
m->accept();
// qDebug() << "legacy mode move:" << m->x() << m->y() << m_canvas->globalToCanvas(m->globalPos()).x() << m_canvas->globalToCanvas(m->globalPos()).y();
// emit MousePos(m->x()/m_canvas->scale(),// + m_doc->minCanvasCoordinate.x(),
// m->y()/m_canvas->scale()); // + m_doc->minCanvasCoordinate.y());
if (commonMouseMove(m))
return;
if (GetItem(&currItem))
{
newX = mousePointDoc.x(); //m_view->translateToDoc(m->x(), m->y()).x());
newY = mousePointDoc.y(); //m_view->translateToDoc(m->x(), m->y()).y());
if (m_doc->DragP)
return;
}
else
{
if ((m_MouseButtonPressed) && (m->buttons() & Qt::LeftButton))
{
newX = mousePointDoc.x();
newY = mousePointDoc.y();
if (createObjectMode == modeDrawLine)
{
if (m_doc->SnapGrid)
{
newX = qRound(newX / m_doc->guidesPrefs().minorGridSpacing) * m_doc->guidesPrefs().minorGridSpacing;
newY = qRound(newY / m_doc->guidesPrefs().minorGridSpacing) * m_doc->guidesPrefs().minorGridSpacing;
}
if (m->modifiers() & Qt::ControlModifier)
{
QRectF bounds(QPointF(createObjectPos.x(), createObjectPos.y()), QPointF(newX, newY));
double newRot = xy2Deg(bounds.width(), bounds.height());
if (newRot < 0.0)
newRot += 360;
newRot = constrainAngle(newRot, m_doc->opToolPrefs().constrain);
double len = qMax(0.01, distance(bounds.width(), bounds.height()));
bounds.setSize(len * QSizeF(cosd(newRot), sind(newRot)));
newX = bounds.right();
newY = bounds.bottom();
}
}
//CB: #8099: Readd snapping for drag creation of lines by commenting this else..
//else
//{
FPoint np2 = m_doc->ApplyGridF(FPoint(newX, newY));
double nx = np2.x();
double ny = np2.y();
m_doc->ApplyGuides(&nx, &ny);
m_doc->ApplyGuides(&nx, &ny,true);
if(nx!=np2.x())
xSnap = nx;
if(ny!=np2.y())
ySnap = ny;
// #8959 : suppress qRound here as this prevent drawing line with angle constrain
// precisely and does not allow to stick precisely to grid or guides
newX = /*qRound(*/nx/*)*/;
newY = /*qRound(*/ny/*)*/;
//}
canvasCurrCoord.setXY(newX, newY);
m_view->HaveSelRect = true;
double wSize = canvasCurrCoord.x() - createObjectPos.x();
double hSize = canvasCurrCoord.y() - createObjectPos.y();
QRectF createObjectRect(createObjectPos.x(), createObjectPos.y(), wSize, hSize);
createObjectRect = createObjectRect.normalized();
if (createObjectMode != modeDrawLine)
{
if (modifiers == Qt::ControlModifier)
hSize = wSize;
m_canvas->displaySizeHUD(m->globalPos(), wSize, hSize, false);
}
else
{
double angle = -xy2Deg(wSize, hSize);
if (angle < 0.0)
angle = angle + 360;
double trueLength = sqrt(pow(createObjectRect.width(), 2) + pow(createObjectRect.height(), 2));
m_canvas->displaySizeHUD(m->globalPos(), trueLength, angle, true);
}
// Necessary for drawControls to be called
m_canvas->repaint();
}
else
m_canvas->displayCorrectedXYHUD(m->globalPos(), mousePointDoc.x(), mousePointDoc.y());
}
}
void BezierMode::mouseReleaseEvent(QMouseEvent *m)
{
const FPoint mousePointDoc = m_canvas->globalToCanvas(m->globalPos());
undoManager->setUndoEnabled(true);
PageItem *currItem;
m_MouseButtonPressed = false;
m_canvas->resetRenderMode();
m->accept();
// m_view->stopDragTimer();
m_canvas->setRenderModeUseBuffer(false);
if ((m_doc->appMode == modeDrawBezierLine) && (m->button() == Qt::LeftButton))
{
m_canvas->setRenderModeUseBuffer(true);
currItem = m_doc->m_Selection->itemAt(0);
currItem->ClipEdited = true;
currItem->FrameType = 3;
QTransform pm = currItem->getTransform();
FPoint npf = m_doc->ApplyGridF(mousePointDoc).transformPoint(pm, true);
currItem->PoLine.addPoint(npf);
bool ssiz = currItem->Sizing;
currItem->Sizing = true;
if ((currItem->PoLine.size() % 4 == 0) && (currItem->PoLine.size() > 3))
{
FPoint lxy(currItem->PoLine.point(currItem->PoLine.size()-2));
FPoint lk(currItem->PoLine.point(currItem->PoLine.size()-1));
double dx = lxy.x() - lk.x();
double dy = lxy.y() - lk.y();
lk.setX(lk.x() + dx*2);
lk.setY(lk.y() + dy*2);
currItem->PoLine.addPoint(lxy);
currItem->PoLine.addPoint(lk);
}
FPoint np2(getMinClipF(&currItem->PoLine));
if (np2.x() < 0)
{
currItem->PoLine.translate(-np2.x(), 0);
m_doc->MoveItem(np2.x(), 0, currItem);
}
if (np2.y() < 0)
{
currItem->PoLine.translate(0, -np2.y());
m_doc->MoveItem(0, np2.y(), currItem);
}
if (FirstPoly)
{
FirstPoly = false;
currItem->Sizing = ssiz;
}
else
{
m_doc->SizeItem(currItem->PoLine.WidthHeight().x(), currItem->PoLine.WidthHeight().y(), currItem, false, false, false);
m_doc->AdjustItemSize(currItem);
currItem->Sizing = ssiz;
currItem->ContourLine = currItem->PoLine.copy();
m_canvas->setRenderModeUseBuffer(false);
currItem->update();
}
m_canvas->setRenderModeFillBuffer();
int newX = qRound(mousePointDoc.x()); //m_view->translateToDoc(m->x(), m->y()).x());
int newY = qRound(mousePointDoc.y()); //m_view->translateToDoc(m->x(), m->y()).y());
m_canvas->newRedrawPolygon() << QPoint(newX - qRound(currItem->xPos()), newY - qRound(currItem->yPos()));
m_view->updateCanvas();
}
if ((m_doc->appMode == modeDrawBezierLine) && (m->button() == Qt::RightButton))
{
currItem = m_doc->m_Selection->itemAt(0);
if (currItem!=0)
{
finalizeItem(currItem);
}
if (!PrefsManager::instance()->appPrefs.uiPrefs.stickyTools)
{
// qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
m_view->requestMode(modeNormal);
// m_view->requestMode(submodePaintingDone);
}
else
m_view->requestMode(m_doc->appMode);
m_doc->changed();
// emit DocChanged();
FirstPoly = true;
inItemCreation = false;
m_canvas->setRenderModeUseBuffer(false);
// m_view->updateContents();
}
m_doc->DragP = false;
m_doc->leaveDrag = false;
// m_canvas->m_viewMode.operItemResizing = false;
m_view->MidButt = false;
shiftSelItems = false;
// m_doc->SubMode = -1;
if (m_view->groupTransactionStarted())
{
for (int i = 0; i < m_doc->m_Selection->count(); ++i)
m_doc->m_Selection->itemAt(i)->checkChanges(true);
m_view->endGroupTransaction();
}
//??? for (int i = 0; i < m_doc->m_Selection->count(); ++i)
//??? m_doc->m_Selection->itemAt(i)->checkChanges(true);
// //Commit drag created items to undo manager.
// if (m_doc->m_Selection->itemAt(0)!=NULL)
// {
// m_doc->itemAddCommit(m_doc->m_Selection->itemAt(0)->ItemNr);
// }
//Make sure the Zoom spinbox and page selector dont have focus if we click on the canvas
m_view->m_ScMW->zoomSpinBox->clearFocus();
m_view->m_ScMW->pageSelector->clearFocus();
if (m_doc->m_Selection->itemAt(0) != 0) // is there the old clip stored for the undo action
{
currItem = m_doc->m_Selection->itemAt(0);
m_doc->nodeEdit.finishTransaction(currItem);
}
else
{
//delete oldClip;
//oldClip = 0;
}
}
bool CreateMode::doOneClick(FPoint& startPoint, FPoint& endPoint)
{
bool doCreate = false;
double xSize, ySize;
int originPoint = 0;
if (QApplication::keyboardModifiers() & Qt::ControlModifier)
return true;
PrefsContext* sizes = PrefsManager::instance()->prefsFile->getContext("ObjectSize");
bool doRemember = sizes->getBool("Remember", true);
int lmode = (createObjectMode == modeDrawLine) ? 1 : 0;
if (lmode == 0)
{
xSize = sizes->getDouble("defWidth", 100.0);
ySize = sizes->getDouble("defHeight", 100.0);
originPoint = sizes->getInt("Origin", 0);
}
else
{
xSize = sizes->getDouble("defLength", 100.0);
ySize = sizes->getDouble("defAngle", 0.0);
originPoint = sizes->getInt("OriginL", 0);
}
//#12577 Remove one click dialog
//#12577 OneClick *dia = new OneClick(m_view, ScribusView::tr("Enter Object Size"), m_doc->unitIndex(), xSize, ySize, doRemember, originPoint, lmode);
//#12577 if (dia->exec())
{
//#12577 doRemember = dia->checkRemember->isChecked();
if (lmode == 0)
{
//#12577 xSize = dia->spinWidth->value() / unitGetRatioFromIndex(m_doc->unitIndex());
//#12577 ySize = dia->spinHeight->value() / unitGetRatioFromIndex(m_doc->unitIndex());
//#12577 originPoint = dia->RotationGroup->checkedId();
if (doRemember)
{
sizes->set("defWidth", xSize);
sizes->set("defHeight", ySize);
sizes->set("Origin", originPoint);
}
endPoint.setXY(startPoint.x() + xSize, startPoint.y() + ySize);
switch (originPoint)
{
case 0:
break;
case 1:
startPoint.setX(startPoint.x() - xSize);
endPoint.setX(endPoint.x() - xSize);
break;
case 2:
startPoint.setXY(startPoint.x() - xSize / 2.0, startPoint.y() - ySize / 2.0);
endPoint.setXY(endPoint.x() - xSize / 2.0, endPoint.y() - ySize / 2.0);
break;
case 3:
startPoint.setY(startPoint.y() - ySize);
endPoint.setY(endPoint.y() - ySize);
break;
case 4:
startPoint.setXY(startPoint.x() - xSize, startPoint.y() - ySize);
endPoint.setXY(endPoint.x() - xSize, endPoint.y() - ySize);
break;
}
}
else
{
FPoint oldStart = startPoint;
//#12577 xSize = dia->spinWidth->value() / unitGetRatioFromIndex(m_doc->unitIndex());
//#12577 ySize = dia->spinHeight->value();
//#12577 originPoint = dia->RotationGroup->checkedId();
if (doRemember)
{
sizes->set("defLength", xSize);
sizes->set("defAngle", ySize);
sizes->set("OriginL", originPoint);
}
double angle = -ySize * M_PI / 180.0;
switch (originPoint)
{
case 0:
endPoint = FPoint(startPoint.x() + xSize * cos(angle), startPoint.y() + xSize * sin(angle));
break;
case 1:
startPoint = FPoint(oldStart.x() - xSize * cos(angle), oldStart.y() - xSize * sin(angle));
endPoint = oldStart;
break;
case 2:
startPoint = FPoint(oldStart.x() - xSize / 2.0 * cos(angle), oldStart.y() - xSize / 2.0 * sin(angle));
endPoint = FPoint(oldStart.x() + xSize / 2.0 * cos(angle), oldStart.y() + xSize / 2.0 * sin(angle));
break;
}
}
sizes->set("Remember", doRemember);
doCreate = true;
}
//delete dia;
return doCreate;
}
void CanvasMode_EditArc::mouseMoveEvent(QMouseEvent *m)
{
const FPoint mousePointDoc = m_canvas->globalToCanvas(m->globalPos());
m->accept();
double newX = mousePointDoc.x();
double newY = mousePointDoc.y();
if (m_canvas->m_viewMode.m_MouseButtonPressed && m_view->moveTimerElapsed())
{
PageItem *currItem = m_doc->m_Selection->itemAt(0);
QTransform itemMatrix;
itemMatrix.translate(currItem->xPos(), currItem->yPos());
itemMatrix.rotate(currItem->rotation());
QPointF sPoint = currItem->PoLine.pointQF(0);
QPointF smPoint = itemMatrix.map(sPoint);
QLineF stLinA = QLineF(smPoint, QPointF(Mxp, Myp));
QLineF stLinM = QLineF(smPoint, QPointF(newX, newY));
double deltaAngle = stLinM.angle() - stLinA.angle();
QPainterPath pp;
if (m_arcPoint == useControlStart)
startAngle += deltaAngle;
else if (m_arcPoint == useControlSweep)
endAngle += deltaAngle;
else if (m_arcPoint == useControlHeight)
heightPoint = QPointF(heightPoint.x(), heightPoint.y() + (newY - Myp));
else if (m_arcPoint == useControlWidth)
widthPoint = QPointF(widthPoint.x() + (newX - Mxp), widthPoint.y());
double nSweep = endAngle - startAngle;
if (nSweep < 0)
nSweep += 360;
double nWidth = sPoint.x() - widthPoint.x();
double nHeight = sPoint.y() - heightPoint.y();
pp.moveTo(sPoint);
pp.arcTo(QRectF(sPoint.x() - nWidth, sPoint.y() - nHeight, nWidth * 2, nHeight * 2), startAngle, nSweep);
pp.closeSubpath();
FPointArray ar;
ar.fromQPainterPath(pp);
if (m_arcPoint == useControlStart)
{
startPoint = ar.pointQF(2);
QLineF stLinA = QLineF(smPoint, itemMatrix.map(startPoint));
m_canvas->displayRotHUD(m->globalPos(), 360.0 - stLinA.angle());
}
else if (m_arcPoint == useControlSweep)
{
endPoint = ar.pointQF(ar.size() - 4);
QLineF stLinA = QLineF(smPoint, itemMatrix.map(endPoint));
m_canvas->displayRotHUD(m->globalPos(), 360.0 - stLinA.angle());
}
QLineF res = QLineF(centerPoint, startPoint);
QLineF swe = QLineF(centerPoint, endPoint);
VectorDialog->setValues(res.angle(), swe.angle(), nHeight * 2, nWidth * 2);
blockUpdateFromItem(true);
currItem->update();
blockUpdateFromItem(false);
QRectF upRect;
upRect = QRectF(QPointF(0, 0), QPointF(currItem->width(), currItem->height())).normalized();
upRect.translate(currItem->xPos(), currItem->yPos());
m_doc->regionsChanged()->update(upRect.adjusted(-10.0 - currItem->width() / 2.0, -10.0 - currItem->height() / 2.0, 10.0 + currItem->width() / 2.0, 10.0 + currItem->height() / 2.0));
}
Mxp = newX;
Myp = newY;
}
void CanvasMode_EditMeshGradient::mousePressEvent(QMouseEvent *m)
{
const FPoint mousePointDoc = m_canvas->globalToCanvas(m->globalPos());
m_canvas->PaintSizeRect(QRect());
m_canvas->m_viewMode.m_MouseButtonPressed = true;
m_canvas->m_viewMode.operItemMoving = false;
m_view->HaveSelRect = false;
m_doc->DragP = false;
m_doc->leaveDrag = false;
m->accept();
m_view->registerMousePress(m->globalPos());
m_Mxp = mousePointDoc.x(); //m->x();
m_Myp = mousePointDoc.y(); //m->y();
if (m->button() == Qt::MidButton)
{
m_view->MidButt = true;
if (m->modifiers() & Qt::ControlModifier)
m_view->DrawNew();
return;
}
PageItem *currItem = m_doc->m_Selection->itemAt(0);
QTransform itemMatrix = currItem->getTransform();
bool found = false;
QPair<int, int> selPoint;
if (m_view->editStrokeGradient == 5)
{
m_gradientPoint = noPointDefined;
for (int grow = 0; grow < currItem->meshGradientArray.count(); grow++)
{
for (int gcol = 0; gcol < currItem->meshGradientArray[grow].count(); gcol++)
{
meshPoint mp = currItem->meshGradientArray[grow][gcol];
QPointF gradientPoint = QPointF(mp.gridPoint.x(), mp.gridPoint.y());
gradientPoint = itemMatrix.map(gradientPoint);
if (m_canvas->hitsCanvasPoint(mousePointDoc, gradientPoint))
{
selPoint.first = grow;
selPoint.second = gcol;
found = true;
*m_old_mesh = mp;
break;
}
}
if (found)
break;
}
}
else if (m_view->editStrokeGradient == 6)
{
m_gradientPoint = noPointDefined;
m_selectedMeshPoints.clear();
for (int grow = 0; grow < currItem->meshGradientArray.count(); grow++)
{
for (int gcol = 0; gcol < currItem->meshGradientArray[grow].count(); gcol++)
{
meshPoint mp = currItem->meshGradientArray[grow][gcol];
QPointF gradientPoint = QPointF(mp.gridPoint.x(), mp.gridPoint.y());
gradientPoint = itemMatrix.map(gradientPoint);
QPointF gradientColorPoint = QPointF(mp.controlColor.x(), mp.controlColor.y());
gradientColorPoint = itemMatrix.map(gradientColorPoint);
if (m_canvas->hitsCanvasPoint(mousePointDoc, gradientPoint) || m_canvas->hitsCanvasPoint(mousePointDoc, gradientColorPoint))
{
selPoint.first = grow;
selPoint.second = gcol;
currItem->selectedMeshPointX = grow;
currItem->selectedMeshPointY = gcol;
*m_old_mesh = mp;
found = true;
break;
}
}
if (found)
break;
}
}
else if (m_view->editStrokeGradient == 7)
{
for (int grow = 0; grow < currItem->meshGradientArray.count(); grow++)
{
for (int gcol = 0; gcol < currItem->meshGradientArray[grow].count(); gcol++)
{
meshPoint mp1 = currItem->meshGradientArray[grow][gcol];
QPointF gradientPoint;
if (grow == 0)
{
if (gcol == 0)
{
gradientPoint = QPointF(mp1.controlRight.x(), mp1.controlRight.y());
if (m_canvas->hitsCanvasPoint(mousePointDoc, itemMatrix.map(gradientPoint)))
{
m_gradientPoint = useControlR;
found = true;
}
gradientPoint = QPointF(mp1.controlBottom.x(), mp1.controlBottom.y());
if (m_canvas->hitsCanvasPoint(mousePointDoc, itemMatrix.map(gradientPoint)))
{
m_gradientPoint = useControlB;
found = true;
}
}
else if (gcol == currItem->meshGradientArray[grow].count()-1)
{
gradientPoint = QPointF(mp1.controlLeft.x(), mp1.controlLeft.y());
if (m_canvas->hitsCanvasPoint(mousePointDoc, itemMatrix.map(gradientPoint)))
{
m_gradientPoint = useControlL;
found = true;
}
gradientPoint = QPointF(mp1.controlBottom.x(), mp1.controlBottom.y());
if (m_canvas->hitsCanvasPoint(mousePointDoc, itemMatrix.map(gradientPoint)))
{
m_gradientPoint = useControlB;
found = true;
}
}
else
{
gradientPoint = QPointF(mp1.controlLeft.x(), mp1.controlLeft.y());
if (m_canvas->hitsCanvasPoint(mousePointDoc, itemMatrix.map(gradientPoint)))
{
m_gradientPoint = useControlL;
found = true;
}
gradientPoint = QPointF(mp1.controlRight.x(), mp1.controlRight.y());
if (m_canvas->hitsCanvasPoint(mousePointDoc, itemMatrix.map(gradientPoint)))
{
m_gradientPoint = useControlR;
found = true;
}
gradientPoint = QPointF(mp1.controlBottom.x(), mp1.controlBottom.y());
if (m_canvas->hitsCanvasPoint(mousePointDoc, itemMatrix.map(gradientPoint)))
{
m_gradientPoint = useControlB;
found = true;
}
}
}
else if (grow == currItem->meshGradientArray.count()-1)
{
if (gcol == 0)
{
gradientPoint = QPointF(mp1.controlRight.x(), mp1.controlRight.y());
if (m_canvas->hitsCanvasPoint(mousePointDoc, itemMatrix.map(gradientPoint)))
{
m_gradientPoint = useControlR;
found = true;
}
gradientPoint = QPointF(mp1.controlTop.x(), mp1.controlTop.y());
if (m_canvas->hitsCanvasPoint(mousePointDoc, itemMatrix.map(gradientPoint)))
{
m_gradientPoint = useControlT;
found = true;
}
}
else if (gcol == currItem->meshGradientArray[grow].count()-1)
{
gradientPoint = QPointF(mp1.controlTop.x(), mp1.controlTop.y());
if (m_canvas->hitsCanvasPoint(mousePointDoc, itemMatrix.map(gradientPoint)))
{
m_gradientPoint = useControlT;
found = true;
}
gradientPoint = QPointF(mp1.controlLeft.x(), mp1.controlLeft.y());
if (m_canvas->hitsCanvasPoint(mousePointDoc, itemMatrix.map(gradientPoint)))
{
m_gradientPoint = useControlL;
found = true;
}
}
else
{
gradientPoint = QPointF(mp1.controlTop.x(), mp1.controlTop.y());
if (m_canvas->hitsCanvasPoint(mousePointDoc, itemMatrix.map(gradientPoint)))
{
m_gradientPoint = useControlT;
found = true;
}
gradientPoint = QPointF(mp1.controlLeft.x(), mp1.controlLeft.y());
if (m_canvas->hitsCanvasPoint(mousePointDoc, itemMatrix.map(gradientPoint)))
{
m_gradientPoint = useControlL;
found = true;
}
gradientPoint = QPointF(mp1.controlRight.x(), mp1.controlRight.y());
if (m_canvas->hitsCanvasPoint(mousePointDoc, itemMatrix.map(gradientPoint)))
{
m_gradientPoint = useControlR;
found = true;
}
}
}
else
{
if (gcol == 0)
{
gradientPoint = QPointF(mp1.controlBottom.x(), mp1.controlBottom.y());
if (m_canvas->hitsCanvasPoint(mousePointDoc, itemMatrix.map(gradientPoint)))
{
m_gradientPoint = useControlB;
found = true;
}
gradientPoint = QPointF(mp1.controlTop.x(), mp1.controlTop.y());
if (m_canvas->hitsCanvasPoint(mousePointDoc, itemMatrix.map(gradientPoint)))
{
m_gradientPoint = useControlT;
found = true;
}
gradientPoint = QPointF(mp1.controlRight.x(), mp1.controlRight.y());
if (m_canvas->hitsCanvasPoint(mousePointDoc, itemMatrix.map(gradientPoint)))
{
m_gradientPoint = useControlR;
found = true;
}
}
else if (gcol == currItem->meshGradientArray[grow].count()-1)
{
gradientPoint = QPointF(mp1.controlBottom.x(), mp1.controlBottom.y());
if (m_canvas->hitsCanvasPoint(mousePointDoc, itemMatrix.map(gradientPoint)))
{
m_gradientPoint = useControlB;
found = true;
}
gradientPoint = QPointF(mp1.controlTop.x(), mp1.controlTop.y());
if (m_canvas->hitsCanvasPoint(mousePointDoc, itemMatrix.map(gradientPoint)))
{
m_gradientPoint = useControlT;
found = true;
}
gradientPoint = QPointF(mp1.controlLeft.x(), mp1.controlLeft.y());
if (m_canvas->hitsCanvasPoint(mousePointDoc, itemMatrix.map(gradientPoint)))
{
m_gradientPoint = useControlL;
found = true;
}
}
else
{
gradientPoint = QPointF(mp1.controlBottom.x(), mp1.controlBottom.y());
if (m_canvas->hitsCanvasPoint(mousePointDoc, itemMatrix.map(gradientPoint)))
{
m_gradientPoint = useControlB;
found = true;
}
gradientPoint = QPointF(mp1.controlTop.x(), mp1.controlTop.y());
if (m_canvas->hitsCanvasPoint(mousePointDoc, itemMatrix.map(gradientPoint)))
{
m_gradientPoint = useControlT;
found = true;
}
gradientPoint = QPointF(mp1.controlLeft.x(), mp1.controlLeft.y());
if (m_canvas->hitsCanvasPoint(mousePointDoc, itemMatrix.map(gradientPoint)))
{
m_gradientPoint = useControlL;
found = true;
}
gradientPoint = QPointF(mp1.controlRight.x(), mp1.controlRight.y());
if (m_canvas->hitsCanvasPoint(mousePointDoc, itemMatrix.map(gradientPoint)))
{
m_gradientPoint = useControlR;
found = true;
}
}
}
if (found)
{
selPoint.first = grow;
selPoint.second = gcol;
*m_old_mesh = mp1;
break;
}
}
if (found)
break;
}
if (!found)
{
for (int grow = 0; grow < currItem->meshGradientArray.count(); grow++)
{
for (int gcol = 0; gcol < currItem->meshGradientArray[grow].count(); gcol++)
{
meshPoint mp = currItem->meshGradientArray[grow][gcol];
QPointF gradientPoint = QPointF(mp.gridPoint.x(), mp.gridPoint.y());
gradientPoint = itemMatrix.map(gradientPoint);
if (m_canvas->hitsCanvasPoint(mousePointDoc, gradientPoint))
{
selPoint.first = grow;
selPoint.second = gcol;
m_gradientPoint = noPointDefined;
found = true;
break;
}
}
if (found)
break;
}
}
}
if (!found)
{
if (!(m->modifiers() & Qt::ShiftModifier))
{
m_gradientPoint = noPointDefined;
m_selectedMeshPoints.clear();
currItem->selectedMeshPointX = -1;
currItem->selectedMeshPointY = -1;
currItem->selectedMeshControlPoint = static_cast<int>(m_gradientPoint);
}
}
else
{
bool isSelected = false;
for (int se = 0; se < m_selectedMeshPoints.count(); se++)
{
if ((selPoint.first == m_selectedMeshPoints[se].first) && (selPoint.second == m_selectedMeshPoints[se].second))
{
isSelected = true;
break;
}
}
if ((!(m->modifiers() & Qt::ShiftModifier)) && (!isSelected))
m_selectedMeshPoints.clear();
if (!isSelected)
m_selectedMeshPoints.append(selPoint);
currItem->selectedMeshPointX = m_selectedMeshPoints[0].first;
currItem->selectedMeshPointY = m_selectedMeshPoints[0].second;
currItem->selectedMeshControlPoint = static_cast<int>(m_gradientPoint);
}
m_canvas->m_viewMode.m_MouseButtonPressed = true;
m_ScMW->propertiesPalette->updateColorSpecialGradient();
m_view->setCursor(QCursor(Qt::CrossCursor));
m_doc->regionsChanged()->update(itemMatrix.mapRect(QRectF(0, 0, currItem->width(), currItem->height())).adjusted(-currItem->width() / 2.0, -currItem->height() / 2.0, currItem->width(), currItem->height()));
}
void RulerGesture::movePoint(QMouseEvent* m, bool mouseRelease)
{
FPoint mousePointDoc = m_canvas->globalToCanvas(m->globalPos());
const int page = m_doc->OnPage(mousePointDoc.x(), mousePointDoc.y());
QRect viewport(m_view->viewport()->mapToGlobal(QPoint(0,0)), QSize(m_view->visibleWidth(), m_view->visibleHeight()));
QPoint newMousePoint = m->globalPos() - (m_canvas->mapToParent(QPoint(0, 0)) + m_canvas->parentWidget()->mapToGlobal(QPoint(0, 0)));
switch (m_mode)
{
case ORIGIN:
m_canvas->repaint();
m_canvas->displayCorrectedXYHUD(m->globalPos(), mousePointDoc.x(), mousePointDoc.y());
break;
case HORIZONTAL:
if (!m_ScMW->doc->guidesSettings.guidesShown)
break;
m_canvas->update(0, m_xy.y()-2, m_canvas->width(), 4);
m_canvas->update(0, newMousePoint.y()-2, m_canvas->width(), 4);
if ((page >= 0) && (viewport.contains(m->globalPos())))
{
if (!m_haveGuide)
{
qApp->changeOverrideCursor(QCursor(Qt::SplitVCursor));
if (mouseRelease)
{
m_doc->Pages->at(page)->guides.addHorizontal(mousePointDoc.y() - m_doc->Pages->at(page)->yOffset(), GuideManagerCore::Standard);
m_guide = mousePointDoc.y() - m_doc->Pages->at(page)->yOffset();
m_page = page;
m_haveGuide = true;
m_doc->changed();
}
}
else if (mouseRelease)
{
if (page == m_page)
m_doc->Pages->at(page)->guides.moveHorizontal( m_guide, mousePointDoc.y() - m_doc->Pages->at(page)->yOffset(), GuideManagerCore::Standard);
else
{
m_doc->Pages->at(m_page)->guides.deleteHorizontal( m_guide, GuideManagerCore::Standard);
m_doc->Pages->at(page)->guides.addHorizontal(mousePointDoc.y() - m_doc->Pages->at(page)->yOffset(), GuideManagerCore::Standard);
m_page = page;
}
if (m_doc->currentPage() != m_doc->Pages->at(m_page))
m_doc->setCurrentPage( m_doc->Pages->at(m_page) );
m_doc->changed();
}
else
{
QCursor* cursor = qApp->overrideCursor();
if (cursor && (cursor->shape() != Qt::SplitVCursor))
qApp->changeOverrideCursor(QCursor(Qt::SplitVCursor));
}
m_currentGuide = mousePointDoc.y() - m_doc->Pages->at(page)->yOffset();
}
else
{
if (m_haveGuide)
{
qApp->changeOverrideCursor(QCursor(loadIcon("DelPoint.png")));
if (mouseRelease)
{
m_doc->Pages->at(m_page)->guides.deleteHorizontal( m_guide, GuideManagerCore::Standard);
m_haveGuide = false;
m_doc->changed();
}
}
}
m_canvas->displayCorrectedSingleHUD(m->globalPos(), mousePointDoc.y(), false);
break;
case VERTICAL:
if (!m_ScMW->doc->guidesSettings.guidesShown)
break;
m_canvas->update(m_xy.x()-2, 0, 4, m_canvas->height());
m_canvas->update(newMousePoint.x()-2, 0, 4, m_canvas->height());
if ((page >= 0) && viewport.contains(m->globalPos()))
{
if (!m_haveGuide)
{
qApp->changeOverrideCursor(QCursor(Qt::SplitHCursor));
if (mouseRelease)
{
m_doc->Pages->at(page)->guides.addVertical(mousePointDoc.x() - m_doc->Pages->at(page)->xOffset(), GuideManagerCore::Standard);
m_guide = mousePointDoc.x() - m_doc->Pages->at(page)->xOffset();
m_page = page;
m_haveGuide = true;
m_doc->changed();
}
}
else if (mouseRelease)
{
if (page == m_page)
m_doc->Pages->at(page)->guides.moveVertical( m_guide, mousePointDoc.x() - m_doc->Pages->at(page)->xOffset(), GuideManagerCore::Standard);
else
{
m_doc->Pages->at(m_page)->guides.deleteVertical( m_guide, GuideManagerCore::Standard);
m_doc->Pages->at(page)->guides.addVertical(mousePointDoc.x() - m_doc->Pages->at(page)->xOffset(), GuideManagerCore::Standard);
m_page = page;
}
if (m_doc->currentPage() != m_doc->Pages->at(m_page))
m_doc->setCurrentPage( m_doc->Pages->at(m_page) );
m_doc->changed();
}
else
{
QCursor* cursor = qApp->overrideCursor();
if (cursor && (cursor->shape() != Qt::SplitHCursor))
qApp->changeOverrideCursor(QCursor(Qt::SplitHCursor));
}
m_currentGuide = mousePointDoc.x() - m_doc->Pages->at(page)->xOffset();
}
else
{
if (m_haveGuide)
{
qApp->changeOverrideCursor(QCursor(loadIcon("DelPoint.png")));
if (mouseRelease)
{
m_doc->Pages->at(m_page)->guides.deleteVertical( m_guide, GuideManagerCore::Standard);
m_haveGuide = false;
m_doc->changed();
}
}
}
m_canvas->displayCorrectedSingleHUD(m->globalPos(), mousePointDoc.x(), true);
break;
}
m_xy = newMousePoint;
}
void XfigPlug::processArrows(int forward_arrow, QString fArrowData, int backward_arrow, QString bArrowData, int depth, PageItem *ite)
{
int arrow_typeAF; // (enumeration type)
int arrow_styleAF; // (enumeration type)
float arrow_thicknessAF; // (1/80 inch)
float arrow_widthAF; // (Fig units)
float arrow_heightAF; // (Fig units)
int arrow_typeAB; // (enumeration type)
int arrow_styleAB; // (enumeration type)
float arrow_thicknessAB; // (1/80 inch)
float arrow_widthAB; // (Fig units)
float arrow_heightAB; // (Fig units)
FPointArray arrow;
int z = -1;
PageItem::ItemType iteType;
if (forward_arrow == 1)
{
arrow.resize(0);
ScTextStream CodeAF(&fArrowData, QIODevice::ReadOnly);
CodeAF >> arrow_typeAF >> arrow_styleAF >> arrow_thicknessAF >> arrow_widthAF >> arrow_heightAF;
arrow_widthAF = fig2Pts(arrow_widthAF);
arrow_heightAF = fig2Pts(arrow_heightAF);
arrow_thicknessAF = arrow_thicknessAF / 80.0 * 72.0;
FPoint End = ite->PoLine.point(ite->PoLine.size()-2);
for (uint xx = ite->PoLine.size()-1; xx > 0; xx -= 2)
{
FPoint Vector = ite->PoLine.point(xx);
if ((End.x() != Vector.x()) || (End.y() != Vector.y()))
{
double r = atan2(End.y()-Vector.y(),End.x()-Vector.x())*(180.0/M_PI);
QTransform arrowTrans;
if (arrow_typeAF == 0)
arrow.parseSVG("M -1, -0.5 L 0, 0 L -1, 0.5");
else if (arrow_typeAF == 1)
arrow.parseSVG("M -1, -0.5 L 0, 0 L -1, 0.5 z");
else if (arrow_typeAF == 2)
arrow.parseSVG("M -1, -0.5 L 0, 0 L -1, 0.5 L -0.7 0 z");
else if (arrow_typeAF == 3)
arrow.parseSVG("M -0.7, -0.5 L 0, 0 L -0.7, 0.5 L -1 0 z");
arrowTrans.translate(End.x(), End.y());
arrowTrans.rotate(r);
arrowTrans.scale(arrow_heightAF, arrow_widthAF);
arrow.map(arrowTrans);
break;
}
}
QString fillC = "White";
if (arrow_styleAF == 1)
fillC = CurrColorStroke;
if (arrow_typeAF == 0)
{
fillC = CommonStrings::None;
iteType = PageItem::PolyLine;
}
else
iteType = PageItem::Polygon;
z = m_Doc->itemAdd(iteType, PageItem::Unspecified, ite->xPos(), ite->yPos(), 10, 10, arrow_thicknessAF, fillC, CurrColorStroke);
if (z >= 0)
{
PageItem *item = m_Doc->Items->at(z);
item->PoLine = arrow.copy();
item->ClipEdited = true;
item->FrameType = 3;
item->setFillShade(CurrFillShade);
item->setLineShade(CurrStrokeShade);
FPoint wh = getMaxClipF(&item->PoLine);
item->setWidthHeight(wh.x(),wh.y());
item->setTextFlowMode(PageItem::TextFlowDisabled);
m_Doc->adjustItemSize(item);
item->setWidthHeight(qMax(item->width(), 1.0), qMax(item->height(), 1.0));
depthMap.insert(999 - depth, currentItemNr);
currentItemNr++;
}
}