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 = currItem->getTransform();
QPointF sPoint = currItem->PoLine.pointQF(0);
QPointF smPoint = itemMatrix.map(sPoint);
QLineF stLinA = QLineF(smPoint, QPointF(m_Mxp, m_Myp));
QLineF stLinM = QLineF(smPoint, QPointF(newX, newY));
double deltaAngle = stLinM.angle() - stLinA.angle();
QPainterPath pp;
if (m_arcPoint == useControlStart)
m_startAngle += deltaAngle;
else if (m_arcPoint == useControlSweep)
m_endAngle += deltaAngle;
else if (m_arcPoint == useControlHeight)
m_heightPoint = QPointF(m_heightPoint.x(), m_heightPoint.y() + (newY - m_Myp));
else if (m_arcPoint == useControlWidth)
m_widthPoint = QPointF(m_widthPoint.x() + (newX - m_Mxp), m_widthPoint.y());
double nSweep = m_endAngle - m_startAngle;
if (nSweep < 0)
nSweep += 360;
double nWidth = sPoint.x() - m_widthPoint.x();
double nHeight = sPoint.y() - m_heightPoint.y();
if ((nWidth > 0) && (nHeight > 0))
{
pp.moveTo(sPoint);
pp.arcTo(QRectF(sPoint.x() - nWidth, sPoint.y() - nHeight, nWidth * 2, nHeight * 2), m_startAngle, nSweep);
pp.closeSubpath();
FPointArray ar;
ar.fromQPainterPath(pp);
if (m_arcPoint == useControlStart)
{
m_startPoint = ar.pointQF(2);
QLineF stLinA = QLineF(smPoint, itemMatrix.map(m_startPoint));
m_canvas->displayRotHUD(m->globalPos(), 360.0 - stLinA.angle());
}
else if (m_arcPoint == useControlSweep)
{
m_endPoint = ar.pointQF(ar.size() - 4);
QLineF stLinA = QLineF(smPoint, itemMatrix.map(m_endPoint));
m_canvas->displayRotHUD(m->globalPos(), 360.0 - stLinA.angle());
}
QLineF res = QLineF(m_centerPoint, m_startPoint);
QLineF swe = QLineF(m_centerPoint, m_endPoint);
vectorDialog->setValues(res.angle(), swe.angle(), nHeight * 2, nWidth * 2);
blockUpdateFromItem(true);
currItem->update();
blockUpdateFromItem(false);
m_doc->regionsChanged()->update(itemMatrix.mapRect(QRectF(0, 0, currItem->width(), currItem->height())).adjusted(-nWidth, -nHeight, nWidth, nHeight));
}
}
m_Mxp = newX;
m_Myp = newY;
}
void ShapeView::startDrag(Qt::DropActions supportedActions)
{
QString key = currentItem()->data(Qt::UserRole).toString();
if (m_Shapes.contains(key))
{
int w = m_Shapes[key].width;
int h = m_Shapes[key].height;
ScribusDoc *m_Doc = new ScribusDoc();
m_Doc->setup(0, 1, 1, 1, 1, "Custom", "Custom");
m_Doc->setPage(w, h, 0, 0, 0, 0, 0, 0, false, false);
m_Doc->addPage(0);
m_Doc->setGUI(false, m_scMW, 0);
int z = m_Doc->itemAdd(PageItem::Polygon, PageItem::Unspecified, m_Doc->currentPage()->xOffset(), m_Doc->currentPage()->yOffset(), w, h, m_Doc->itemToolPrefs().shapeLineWidth, m_Doc->itemToolPrefs().shapeFillColor, m_Doc->itemToolPrefs().shapeLineColor, true);
PageItem* ite = m_Doc->Items->at(z);
ite->PoLine = m_Shapes[key].path.copy();
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();
ite->updateClip();
ite->ClipEdited = true;
ite->FrameType = 3;
m_Doc->m_Selection->addItem(ite, true);
ScElemMimeData* md = ScriXmlDoc::WriteToMimeData(m_Doc, m_Doc->m_Selection);
QDrag* dr = new QDrag(this);
dr->setMimeData(md);
dr->setPixmap(currentItem()->icon().pixmap(QSize(48, 48)));
dr->exec();
delete m_Doc;
}
}
void CanvasMode_Magnifier::mouseMoveEvent(QMouseEvent *m)
{
// const double mouseX = m->globalX();
// const double mouseY = m->globalY();
const FPoint mousePointDoc = m_canvas->globalToCanvas(m->globalPos());
m_lastPosWasOverGuide = false;
double newX, newY;
m->accept();
if (commonMouseMove(m))
return;
if ((m_canvas->m_viewMode.m_MouseButtonPressed) && (m->buttons() & Qt::LeftButton))
{
newX = qRound(mousePointDoc.x()); //m_view->translateToDoc(m->x(), m->y()).x());
newY = qRound(Myp + ((SeRx - Mxp) * m_view->visibleHeight()) / m_view->visibleWidth());
SeRx = newX;
SeRy = newY;
/*
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? 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;
}
}
void ResizeGesture::mousePressEvent(QMouseEvent *m)
{
FPoint point = m_canvas->globalToCanvas(m->globalPos());
m_mousePressPoint = m->globalPos();
if (m_doc->m_Selection->count() == 0)
{
m_handle = Canvas::OUTSIDE;
}
else if (m_doc->m_Selection->isMultipleSelection())
{
double gx, gy, gh, gw;
m_doc->m_Selection->getVisualGroupRect(&gx, &gy, &gw, &gh);
m_handle = m_canvas->frameHitTest(QPointF(point.x(), point.y()), QRectF(gx,gy,gw,gh));
}
else
{
m_handle = m_canvas->frameHitTest(QPointF(point.x(), point.y()), m_doc->m_Selection->itemAt(0));
}
if (m_handle > 0)
{
prepare(m_handle);
m->accept();
m_mousePressBounds = m_bounds;
}
}
bool RulerGesture::mouseHitsGuide(FPoint mousePointDoc)
{
const int page = m_doc->OnPage(mousePointDoc.x(), mousePointDoc.y());
if ((m_doc->guidesSettings.guidesShown) && (!m_doc->GuideLock) && page >= 0)
{
double grabRadScale = m_doc->guidesSettings.grabRad / m_canvas->scale();
int index = m_doc->Pages->at(page)->guides.isMouseOnVertical(mousePointDoc.x() + grabRadScale, mousePointDoc.x() - grabRadScale, GuideManagerCore::Standard);
if (index >= 0)
{
m_mode = VERTICAL;
m_haveGuide = true;
m_guide = m_doc->Pages->at(page)->guides.vertical(index, GuideManagerCore::Standard);
m_currentGuide = m_guide;
m_page = page;
return true;
}
index = m_doc->Pages->at(page)->guides.isMouseOnHorizontal(mousePointDoc.y() + grabRadScale, mousePointDoc.y() - grabRadScale, GuideManagerCore::Standard);
if (index >= 0)
{
m_mode = HORIZONTAL;
m_haveGuide = true;
m_guide = m_doc->Pages->at(page)->guides.horizontal(index, GuideManagerCore::Standard);
m_currentGuide = m_guide;
m_page = page;
return true;
}
}
m_haveGuide = false;
return false;
}
void CanvasMode_ObjImport::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;
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;
// oldClip = 0;
m->accept();
m_view->registerMousePress(m->globalPos());
Mxp = mousePointDoc.x();
Myp = mousePointDoc.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;
}
}
void KCurve::keyPressEvent(QKeyEvent *e)
{
if(e->key() == Qt::Key_Delete || e->key() == Qt::Key_Backspace)
{
if (m_points.size() > 2)
{
FPoint closest_point = m_points.point(0);
FPoint p = m_points.point(0);
int pos = 0;
int cc = 0;
double distance = 1000; // just a big number
while(cc < m_points.size())
{
p = m_points.point(cc);
if (fabs (m_grab_point.x() - p.x()) < distance)
{
distance = fabs(m_grab_point.x() - p.x());
closest_point = p;
m_pos = pos;
}
cc++;
pos++;
}
FPointArray cli;
cli.putPoints(0, m_pos, m_points);
cli.putPoints(cli.size(), m_points.size()-m_pos-1, m_points, m_pos+1);
m_points.resize(0);
m_points = cli.copy();
m_grab_point = closest_point;
repaint();
emit modified();
QWidget::keyPressEvent(e);
}
}
}
void CanvasMode_Rotate::drawItemOutlines(QPainter* p)
{
FPoint itemPos;
double itemRotation;
p->save();
QColor drawColor = qApp->palette().color(QPalette::Active, QPalette::Highlight);
p->setRenderHint(QPainter::Antialiasing);
p->setBrush(Qt::NoBrush);
p->setPen(QPen(drawColor, 1, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin));
uint docSelectionCount = m_doc->m_Selection->count();
for (uint i = 0; i < docSelectionCount; ++i)
{
PageItem * currItem = m_doc->m_Selection->itemAt(i);
getNewItemPosition(currItem, itemPos, itemRotation);
p->save();
p->translate(itemPos.x(), itemPos.y());
p->rotate(itemRotation);
currItem->DrawPolyL(p, currItem->Clip);
p->restore();
}
p->restore();
}
void LineMove::adjustBounds(QMouseEvent *m)
{
FPoint mousePointDoc = m_canvas->globalToCanvas(m->globalPos());
bool constrainRatio = ((m->modifiers() & Qt::ControlModifier) != Qt::NoModifier);
double newX = mousePointDoc.x();
double newY = mousePointDoc.y();
if (m_doc->useRaster)
{
newX = qRound(newX / m_doc->guidesSettings.minorGridSpacing) * m_doc->guidesSettings.minorGridSpacing;
newY = qRound(newY / m_doc->guidesSettings.minorGridSpacing) * m_doc->guidesSettings.minorGridSpacing;
}
//<<#8099
FPoint np2 = m_doc->ApplyGridF(FPoint(newX, newY));
double nx = np2.x();
double ny = np2.y();
m_doc->ApplyGuides(&nx, &ny);
newX = qRound(nx);
newY = qRound(ny);
//>>#8099
m_bounds.setBottomRight(QPointF(newX, newY));
//Constrain rotation angle, when the mouse is being dragged around for a new line
if (constrainRatio)
{
double newRot = rotation();
newRot = constrainAngle(newRot, m_doc->opToolPrefs.constrain);
setRotation(newRot);
}
// qDebug() << "LineMove::adjustBounds" << m_bounds << rotation() << length() << m_bounds.bottomRight();
m_view->updateCanvas(m_bounds.normalized().adjusted(-10, -10, 20, 20));
}
void CalligraphicMode::selectPage(QMouseEvent *m)
{
m_MouseButtonPressed = true;
FPoint mousePointDoc = m_canvas->globalToCanvas(m->globalPos());
Mxp = mousePointDoc.x(); //static_cast<int>(m->x()/m_canvas->scale());
Myp = mousePointDoc.y(); //static_cast<int>(m->y()/m_canvas->scale());
QRect mpo(m->x()-m_doc->guidesPrefs().grabRadius, m->y()-m_doc->guidesPrefs().grabRadius, m_doc->guidesPrefs().grabRadius*2, m_doc->guidesPrefs().grabRadius*2);
m_doc->nodeEdit.deselect();
m_view->Deselect(false);
if (!m_doc->masterPageMode())
{
int i = m_doc->OnPage(Mxp, Myp);
if (i!=-1)
{
uint docCurrPageNo=m_doc->currentPageNumber();
uint j=static_cast<uint>(i);
if (docCurrPageNo != j)
{
m_doc->setCurrentPage(m_doc->Pages->at(j));
m_view->m_ScMW->slotSetCurrentPage(j);
m_view->DrawNew();
}
}
}
}
void ScPainterEx_GDI::drawLine(FPoint start, FPoint end)
{
newPath();
moveTo(start.x(), start.y());
lineTo(end.x(), end.y());
strokePath();
}
void CanvasMode_FrameLinks::selectPage(QMouseEvent *m)
{
m_canvas->m_viewMode.m_MouseButtonPressed = true;
FPoint mousePointDoc = m_canvas->globalToCanvas(m->globalPos());
Mxp = mousePointDoc.x(); //static_cast<int>(m->x()/m_canvas->scale());
Myp = mousePointDoc.y(); //static_cast<int>(m->y()/m_canvas->scale());
m_doc->nodeEdit.deselect();
m_view->Deselect(false);
if (!m_doc->masterPageMode())
{
int i = m_doc->OnPage(Mxp, Myp);
if (i!=-1)
{
uint docCurrPageNo=m_doc->currentPageNumber();
uint j=static_cast<uint>(i);
if (docCurrPageNo != j)
{
m_doc->setCurrentPage(m_doc->Pages->at(j));
m_view->setMenTxt(j);
m_view->DrawNew();
}
}
m_view->setRulerPos(m_view->contentsX(), m_view->contentsY());
}
}
void ScPainterEx_GDI::transformPoint( const FPoint& in, FPoint& out )
{
double x, y;
x = in.x() * m_matrix.m11() + in.y() * m_matrix.m21() + m_matrix.dx();
y = in.x() * m_matrix.m12() + in.y() * m_matrix.m22() + m_matrix.dy();
out.setX( x );
out.setY( y );
}
void CanvasMode_EditSpiral::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() && (m_arcPoint != noPointDefined))
{
PageItem *currItem = m_doc->m_Selection->itemAt(0);
QTransform itemMatrix = currItem->getTransform();
PageItem_Spiral *item = currItem->asSpiral();
QPointF sPoint;
if (m_arcPoint == useControlStart)
sPoint = getSegment(m_startAngle);
else if (m_arcPoint == useControlEnd)
sPoint = getSegment(m_endAngle);
QPointF smPoint = itemMatrix.map(sPoint);
QLineF stLinA = QLineF(smPoint, QPointF(m_Mxp, m_Myp));
QLineF stLinM = QLineF(smPoint, QPointF(newX, newY));
double deltaAngle = stLinM.angle() - stLinA.angle();
if (deltaAngle < -180)
deltaAngle = deltaAngle + 360;
else if (deltaAngle > 180)
deltaAngle = deltaAngle - 360;
if (currItem->imageFlippedV())
deltaAngle *= -1.0;
if (currItem->imageFlippedH())
deltaAngle *= -1.0;
if (m_arcPoint == useControlStart)
{
if (m_startAngle + deltaAngle >= 0)
{
m_startAngle += deltaAngle;
applyValues(m_startAngle,m_endAngle,item->spiralFactor);
item->recalcPath();
m_startPoint = currItem->PoLine.pointQF(0);
m_canvas->displayRealRotHUD(m->globalPos(), m_startAngle);
}
m_VectorDialog->setValues(computeRealAngle(m_startAngle, false), computeRealAngle(m_endAngle, false), item->spiralFactor);
}
else if (m_arcPoint == useControlEnd)
{
if (m_endAngle + deltaAngle > m_startAngle)
{
m_endAngle += deltaAngle;
applyValues(m_startAngle,m_endAngle,item->spiralFactor);
item->recalcPath();
m_endPoint = currItem->PoLine.pointQF(currItem->PoLine.size() - 2);
m_canvas->displayRealRotHUD(m->globalPos(), m_endAngle);
}
m_VectorDialog->setValues(computeRealAngle(m_startAngle, false), computeRealAngle(m_endAngle, false), item->spiralFactor);
}
currItem->update();
m_doc->regionsChanged()->update(itemMatrix.mapRect(QRectF(0, 0, currItem->width(), currItem->height())).adjusted(-5, -5, 10, 10));
}
m_Mxp = newX;
m_Myp = newY;
}
void CurveWidget::doInvert()
{
FPointArray curve = cDisplay->getCurve();
for (int a = 0; a < curve.size(); a++)
{
FPoint p = curve.point(a);
curve.setPoint(a, p.x(), 1.0 - p.y());
}
cDisplay->setCurve(curve);
}
void CanvasMode_EditPolygon::mouseReleaseEvent(QMouseEvent *m)
{
const FPoint mousePointDoc = m_canvas->globalToCanvas(m->globalPos());
m_canvas->m_viewMode.m_MouseButtonPressed = false;
m_canvas->resetRenderMode();
m->accept();
PageItem *currItem = m_doc->m_Selection->itemAt(0);
PageItem_RegularPolygon* item = currItem->asRegularPolygon();
QTransform itemMatrix = currItem->getTransform();
if ((m_polygonPoint == useControlInner) || (m_polygonPoint == useControlOuter) || (m_polygonPoint == useControlInnerCurve) || (m_polygonPoint == useControlOuterCurve))
{
double newX = mousePointDoc.x();
double newY = mousePointDoc.y();
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;
polyFactor = 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));
}
if (m_polygonPoint == useControlOuter)
polyRotation = stLinA.angle() - 90;
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();
}
item->polyFactor = polyFactor;
item->polyRotation = polyRotation;
item->polyCurvature = polyCurvature;
item->polyInnerRot = polyInnerRot;
item->polyOuterCurvature = polyOuterCurvature;
item->recalcPath();
VectorDialog->setValues(polyCorners, polyFactor, polyUseFactor, polyRotation, polyCurvature, polyInnerRot, polyOuterCurvature);
if (m_transaction)
{
m_transaction.commit();
m_transaction.reset();
}
}
QPainterPath path = itemMatrix.map(RegularPolygonPath(item->width(), item->height(), polyCorners, polyUseFactor, polyFactor, polyRotation, polyCurvature, polyInnerRot, polyOuterCurvature));
m_doc->regionsChanged()->update(path.boundingRect().adjusted(-5, -5, 10, 10));
}
void DrawModel( const PorousModel& model )
{
const static FPoint radius( 0.5, 0.5, 0.5 );
static Point<long> pnt;
static Point<ulong> sz;
static FPoint center, p;
GLfloat material[3];
COLORREF color;
GLUquadric *q = gluNewQuadric();
sz = model.GetSize();
center.Init( 0.5f*sz.x, 0.5f*sz.y, 0.5f*sz.z );
double volume = double(sz.x)*sz.y*sz.z;
int quality;
if( volume < 1e6 )
quality = 10;
else if ( volume < 1e9 )
quality = 5;
else
quality = 3;
for( pnt.x = 0; pnt.x < long(sz.x); ++pnt.x )
for( pnt.y = 0; pnt.y < long(sz.y); ++pnt.y )
for( pnt.z = 0; pnt.z < long(sz.z); ++pnt.z )
if( model.GetCellColor( pnt, &color ) )
{
material[0] = float(GetRValue(color))/0xFF;
material[1] = float(GetGValue(color))/0xFF;
material[2] = float(GetBValue(color))/0xFF;
glMaterialfv( GL_FRONT, GL_DIFFUSE, material );
copy_vector( p, pnt );
p += radius;
p -= center;
glTranslatef( p.x, -p.z, -p.y );
gluSphere( q, 0.7, quality, quality );
glTranslatef( -p.x, p.z, p.y );
}
//material[0] = material[1] = 1.0f;
//material[2] = 0.0f;
//glMaterialfv( GL_FRONT, GL_DIFFUSE, material );
//glTranslatef( -sz.x/5, sz.z/5, 0 );
//gluSphere( q, 1, 10, 10 );
//glTranslatef( sz.x/5, -sz.z/5, 0 );
//gluDeleteQuadric( q );
}
void CanvasMode_ObjImport::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;
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;
// oldClip = 0;
m->accept();
m_view->registerMousePress(m->globalPos());
Mxp = mousePointDoc.x();
Myp = mousePointDoc.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) && m_mimeData)
{
UndoTransaction* undoTransaction = NULL;
if (m_trSettings && UndoManager::undoEnabled())
{
undoTransaction = new 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());
QDropEvent dropEvent(dropPos, Qt::CopyAction|Qt::MoveAction, m_mimeData, m->buttons(), m->modifiers());
m_view->contentsDropEvent(&dropEvent);
// Commit undo transaction if necessary
if (undoTransaction)
{
undoTransaction->commit();
delete undoTransaction;
undoTransaction = NULL;
}
// Return to normal mode
m_view->requestMode(modeNormal);
}
}
QPointF TableGesture::globalToTableGrid(const QPoint point, bool snap)
{
FPoint canvasPoint = m_canvas->globalToCanvas(point);
if (snap)
{
// Snap to grid and guides.
canvasPoint = m_doc->ApplyGridF(canvasPoint);
m_doc->ApplyGuides(&canvasPoint);
}
// Return point mapped to table grid.
return m_table->getTransform().inverted().map(canvasPoint.toQPointF()) - m_table->gridOffset();
}
void MeasurementsMode::mouseMoveEvent(QMouseEvent *m)
{
if (m_active)
{
m->accept();
adjustPoint(m->globalPos());
showValues();
}
else
{
FPoint mousePointDoc = m_canvas->globalToCanvas(m->globalPos());
m_canvas->displayCorrectedXYHUD(m->globalPos(), mousePointDoc.x(), mousePointDoc.y());
}
}
void LevelEndBonusController::Update(float dt)
{
local_time += dt;
if( local_time >= 0.0f )
{
Game::FieldAddress address(_center);
FPoint pos = GameSettings::gamefield[address]->GetCellPos() + GameSettings::CELL_HALF;
ParticleEffectPtr eff = Game::AddEffect(gameField->_effTopCont, "LineBonusChip_0");
eff->SetPos(pos);
eff->Reset();
gameField->addWave(pos.Rounded(), 0.02f, 1000.0f, 125.0f);
}
}
void CanvasMode_EditArc::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;
}
QTransform itemMatrix;
PageItem *currItem = m_doc->m_Selection->itemAt(0);
itemMatrix.translate(currItem->xPos(), currItem->yPos());
itemMatrix.rotate(currItem->rotation());
QPointF stPoint = startPoint;
stPoint = itemMatrix.map(stPoint);
QPointF swPoint = endPoint;
swPoint = itemMatrix.map(swPoint);
QPointF shPoint = heightPoint;
shPoint = itemMatrix.map(shPoint);
QPointF sPoint = widthPoint;
sPoint = itemMatrix.map(sPoint);
if (m_canvas->hitsCanvasPoint(m->globalPos(), stPoint))
m_arcPoint = useControlStart;
else if (m_canvas->hitsCanvasPoint(m->globalPos(), swPoint))
m_arcPoint = useControlSweep;
else if (m_canvas->hitsCanvasPoint(m->globalPos(), shPoint))
m_arcPoint = useControlHeight;
else if (m_canvas->hitsCanvasPoint(m->globalPos(), sPoint))
m_arcPoint = useControlWidth;
else
m_arcPoint = noPointDefined;
m_canvas->m_viewMode.m_MouseButtonPressed = true;
qApp->changeOverrideCursor(QCursor(Qt::CrossCursor));
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));
}
void KCurve::paintEvent(QPaintEvent *)
{
int x = 0;
int wWidth = width() - 1;
int wHeight = height() - 1;
// Drawing selection or all histogram values.
QPainter p1;
p1.begin(this);
// draw background
p1.fillRect(QRect(0, 0, wWidth, wHeight), QColor(255, 255, 255));
// Draw grid separators.
p1.setPen(QPen(Qt::gray, 1, Qt::SolidLine));
p1.drawLine(wWidth/4, 0, wWidth/4, wHeight);
p1.drawLine(wWidth/2, 0, wWidth/2, wHeight);
p1.drawLine(3*wWidth/4, 0, 3*wWidth/4, wHeight);
p1.drawLine(0, wHeight/4, wWidth, wHeight/4);
p1.drawLine(0, wHeight/2, wWidth, wHeight/2);
p1.drawLine(0, 3*wHeight/4, wWidth, 3*wHeight/4);
// Draw curve.
double curvePrevVal = getCurveValue(0.0);
p1.setPen(QPen(Qt::black, 1, Qt::SolidLine));
for (x = 0 ; x < wWidth ; x++)
{
double curveX;
double curveVal;
// curveX = (x + 0.5) / wWidth;
curveX = x / static_cast<double>(wWidth);
curveVal = getCurveValue(curveX);
p1.drawLine(x - 1, wHeight - int(curvePrevVal * wHeight), x, wHeight - int(curveVal * wHeight));
curvePrevVal = curveVal;
}
p1.drawLine(x - 1, wHeight - int(curvePrevVal * wHeight), x, wHeight - int(getCurveValue(1.0) * wHeight));
for (int dh = 0; dh < m_points.size(); dh++)
{
FPoint p = m_points.point(dh);
if(p == m_grab_point)
{
p1.setPen(QPen(Qt::red, 3, Qt::SolidLine));
p1.drawEllipse( int(p.x() * wWidth) - 2, wHeight - 2 - int(p.y() * wHeight), 4, 4 );
}
else
{
p1.setPen(QPen(Qt::red, 1, Qt::SolidLine));
p1.drawEllipse( int(p.x() * wWidth) - 3, wHeight - 3 - int(p.y() * wHeight), 6, 6 );
}
}
p1.end();
}
void CanvasMode_Normal::mouseMoveEvent(QMouseEvent *m)
{
// qDebug()<<"CanvasMode_Normal::mouseMoveEvent";
// const double mouseX = m->globalX();
// const double mouseY = m->globalY();
const FPoint mousePointDoc = m_canvas->globalToCanvas(m->globalPos());
m_lastPosWasOverGuide = false;
double newX, newY;
PageItem *currItem;
bool erf = false;
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;
m_mouseCurrentPoint = mousePointDoc;
if ((m_doc->guidesSettings.guidesShown) && (!m_doc->GuideLock) && (m_doc->OnPage(mousePointDoc.x(), mousePointDoc.y()) != -1) )
{
if( ((m_doc->guidesSettings.before) && (m_canvas->itemUnderCursor(m->globalPos()))) == false )
{
if (!guideMoveGesture)
{
guideMoveGesture = new RulerGesture(m_view, RulerGesture::HORIZONTAL);
connect(guideMoveGesture,SIGNAL(guideInfo(int, qreal)), m_ScMW->alignDistributePalette,SLOT(setGuide(int, qreal)));
}
if (guideMoveGesture->mouseHitsGuide(mousePointDoc))
{
m_lastPosWasOverGuide = true;
switch (guideMoveGesture->getMode())
{
case RulerGesture::HORIZONTAL:
qApp->changeOverrideCursor(QCursor(Qt::SplitVCursor));
break;
case RulerGesture::VERTICAL:
qApp->changeOverrideCursor(QCursor(Qt::SplitHCursor));
break;
default:
qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
}
return;
}
// Here removed a bunch of comments which made reading code difficult,
// there is svn for tracking changes after all. pm
qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
}
}
void SpriteCardItem::Draw(const FPoint &shift)
{
if(part.texture->IsLoaded())
{
part.texture->Draw(part.screenRect.MovedBy(shift.Rounded()), part.textureUV);
}
}
void BezierMode::selectPage(QMouseEvent *m)
{
m_MouseButtonPressed = true;
FPoint mousePointDoc = m_canvas->globalToCanvas(m->globalPos());
Mxp = mousePointDoc.x(); //static_cast<int>(m->x()/m_canvas->scale());
Myp = mousePointDoc.y(); //static_cast<int>(m->y()/m_canvas->scale());
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(Doc->minCanvasCoordinate.x() * m_canvas->scale()), qRound(m_doc->minCanvasCoordinate.y() * m_canvas->scale()));
m_doc->nodeEdit.deselect();
m_view->Deselect(false);
if (!m_doc->masterPageMode())
{
int i = m_doc->OnPage(Mxp, Myp);
if (i!=-1)
{
uint docCurrPageNo=m_doc->currentPageNumber();
uint j=static_cast<uint>(i);
if (docCurrPageNo != j)
{
m_doc->setCurrentPage(m_doc->Pages->at(j));
m_view->m_ScMW->slotSetCurrentPage(j);
m_view->DrawNew();
}
}
/* uint docPagesCount=m_doc->Pages->count();
uint docCurrPageNo=m_doc->currentPageNumber();
for (uint i = 0; i < docPagesCount; ++i)
{
int x = static_cast<int>(m_doc->Pages->at(i)->xOffset() * m_canvas->scale());
int y = static_cast<int>(m_doc->Pages->at(i)->yOffset() * m_canvas->scale());
int w = static_cast<int>(m_doc->Pages->at(i)->width() * m_canvas->scale());
int h = static_cast<int>(m_doc->Pages->at(i)->height() * m_canvas->scale());
if (QRect(x, y, w, h).intersects(mpo))
{
if (docCurrPageNo != i)
{
m_doc->setCurrentPage(m_doc->Pages->at(i));
setMenTxt(i);
DrawNew();
}
break;
}
} */
//FIXME m_view->setRulerPos(m_view->contentsX(), m_view->contentsY());
}
}
void ArrowChooser::rebuildList(QList<ArrowDesc> *arrowStyles)
{
clear();
FPointArray Path;
Path.resize(0);
addItem(CommonStrings::tr_None);
for (int a = 0; a < arrowStyles->count(); ++a)
{
QImage image(22, 22, QImage::Format_ARGB32);
ScPainter *painter = new ScPainter(&image, 22, 22);
painter->clear();
painter->setBrush(qRgb(0, 0, 0));
painter->setPen(qRgb(0, 0, 0));
painter->setFillMode(1);
painter->translate(3.0, 3.0);
Path.resize(0);
Path = arrowStyles->at(a).points.copy();
FPoint min = getMinClipF(&Path);
Path.translate(-min.x(), -min.y());
FPoint max = Path.WidthHeight();
QMatrix mm;
QMatrix mm2;
if (arrowDirection)
{
mm2.scale(-1, 1);
mm2.translate(-max.x(), 0);
}
mm.scale(16.0 / qMax(max.x(), max.y()), 16.0 / qMax(max.x(), max.y()));
Path.map(mm2 * mm);
painter->setupPolygon(&Path);
painter->setLineWidth(1.0);
painter->drawPolygon();
painter->drawPolyLine();
painter->end();
delete painter;
int wi = image.width();
int hi = image.height();
for( int yi=0; yi < hi; ++yi )
{
QRgb *s = (QRgb*)(image.scanLine( yi ));
for(int xi=0; xi < wi; ++xi )
{
if((*s) == 0xffffffff)
(*s) &= 0x00ffffff;
s++;
}
}
QPixmap Ico;
Ico=QPixmap::fromImage(image);
addItem(Ico, arrowStyles->at(a).name);
}
}
void CanvasMode_CopyProperties::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();
if ((GetItem(&currItem)) && (m->button() == Qt::RightButton) && (!m_doc->DragP))
{
createContextMenu(currItem, mousePointDoc.x(), mousePointDoc.y());
return;
}
}
void CanvasMode_Magnifier::mousePressEvent(QMouseEvent *m)
{
double Rxp = 0, Ryp = 0;
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(); //qRound(m->x()/m_canvas->scale() + 0*m_doc->minCanvasCoordinate.x());
m_Myp = mousePointDoc.y(); //qRound(m->y()/m_canvas->scale() + 0*m_doc->minCanvasCoordinate.y());
Rxp = m_doc->ApplyGridF(FPoint(m_Mxp, m_Myp)).x();
m_Mxp = qRound(Rxp);
Ryp = m_doc->ApplyGridF(FPoint(m_Mxp, m_Myp)).y();
m_Myp = qRound(Ryp);
m_SeRx = m_Mxp;
m_SeRy = m_Myp;
if (m->button() == Qt::MidButton)
{
m_view->MidButt = true;
if (m->modifiers() & Qt::ControlModifier)
m_view->DrawNew();
return;
}
m_canvas->m_viewMode.m_MouseButtonPressed = true;
if ((m->modifiers() == Qt::ShiftModifier) || (m->button() == Qt::RightButton))
{
m_view->Magnify = false;
m_view->setCursor(IconManager::instance()->loadCursor("lupezm.png"));
}
else
{
m_view->Magnify = true;
m_view->setCursor(IconManager::instance()->loadCursor("lupez.png"));
}
m_Mxp = mousePointDoc.x(); //m->globalPos().x();
m_Myp = mousePointDoc.y(); //m->globalPos().y();
m_SeRx = m_Mxp;
m_SeRy = m_Myp;
m_view->redrawMarker->setGeometry(m->globalPos().x(), m->globalPos().y(), 1, 1);
}
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 = NULL;
if (m_trSettings && UndoManager::undoEnabled())
{
undoTransaction = new 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();
delete undoTransaction;
undoTransaction = NULL;
}
// 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();
}