void QgsLayoutItemPolyline::drawStartMarker( QPainter *painter )
{
if ( mPolygon.size() < 2 )
return;
switch ( mStartMarker )
{
case MarkerMode::NoMarker:
break;
case MarkerMode::ArrowHead:
{
// calculate angle at start of line
QLineF startLine( mPolygon.at( 0 ), mPolygon.at( 1 ) );
double angle = startLine.angle();
drawArrow( painter, mPolygon.at( 0 ), angle );
break;
}
case MarkerMode::SvgMarker:
{
// calculate angle at start of line
QLineF startLine( mPolygon.at( 0 ), mPolygon.at( 1 ) );
double angle = startLine.angle();
drawSvgMarker( painter, mPolygon.at( 0 ), angle, mStartMarkerFile, mStartArrowHeadHeight );
break;
}
}
}
static void
PrintGasConstantDecl(FILE *f, AST *ast, int inlineAsm)
{
startLine(f, inlineAsm);
fprintf(f, "\t\t.equ\t%s, ", ast->d.string);
PrintInteger(f, EvalConstExpr(ast));
endLine(f, inlineAsm);
}
void ScopedPrinter::printBinaryImpl(StringRef Label, StringRef Str,
ArrayRef<uint8_t> Data, bool Block,
uint32_t StartOffset) {
if (Data.size() > 16)
Block = true;
if (Block) {
startLine() << Label;
if (!Str.empty())
OS << ": " << Str;
OS << " (\n";
if (!Data.empty())
OS << format_bytes_with_ascii(Data, StartOffset, 16, 4,
(IndentLevel + 1) * 2, true)
<< "\n";
startLine() << ")\n";
} else {
startLine() << Label << ":";
if (!Str.empty())
OS << " " << Str;
OS << " (" << format_bytes(Data, None, Data.size(), 1, 0, true) << ")\n";
}
}
void UBGraphicsProtractor::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
{
QPointF currentPoint = event->pos();
QLineF startLine(rect().center(), mPreviousMousePos);
QLineF currentLine(rect().center(), currentPoint);
qreal angle = startLine.angleTo(currentLine);
qreal scaleFactor = currentLine.length()/startLine.length();
switch (mCurrentTool)
{
case Rotate :
prepareGeometryChange();
mStartAngle = mStartAngle + angle;
setStartAngle(mStartAngle * 16);
mPreviousMousePos = currentPoint;
break;
case Resize :
prepareGeometryChange();
translate(rect().center().x(), rect().center().y());
scale(scaleFactor, scaleFactor);
translate(-rect().center().x(), -rect().center().y());
mScaleFactor *= scaleFactor;
break;
case MoveMarker :
mCurrentAngle += angle;
if ((int)mCurrentAngle % 360 > 270)
mCurrentAngle = 0;
else if ((int)mCurrentAngle % 360 >= 180)
mCurrentAngle = 180;
mPreviousMousePos = currentPoint;
update();
break;
case Move :
QGraphicsEllipseItem::mouseMoveEvent(event);
break;
default :
break;
}
if (mCurrentTool != Move)
event->accept();
}
Graphics::Surface *TinyGLRenderer::getScreenshot() {
Graphics::Surface *s = new Graphics::Surface();
s->create(kOriginalWidth, kOriginalHeight, Graphics::PixelFormat(4, 8, 8, 8, 8, 0, 8, 16, 24));
Graphics::PixelBuffer buf(s->format, (byte *)s->getPixels());
_fb->copyToBuffer(buf);
//Vertical flip in place:
Graphics::PixelBuffer startLine(s->format, kOriginalWidth, DisposeAfterUse::YES);
Graphics::PixelBuffer endLine(s->format, kOriginalWidth, DisposeAfterUse::YES);
for(int y = 0; y < kOriginalHeight / 2; y++)
{
startLine.copyBuffer(0, y * kOriginalWidth, kOriginalWidth, buf);
endLine.copyBuffer(0, (kOriginalHeight - y - 1) * kOriginalWidth, kOriginalWidth, buf);
buf.copyBuffer(y * kOriginalWidth, 0, kOriginalWidth, endLine);
buf.copyBuffer((kOriginalHeight - y - 1) * kOriginalWidth, 0, kOriginalWidth, startLine);
}
return s;
}
void UBGraphicsDelegateFrame::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
{
if (None == mCurrentTool)
return;
QLineF move = QLineF(mStartingPoint, event->scenePos());
qreal moveX = move.length() * cos((move.angle() - mAngle) * PI / 180);
qreal moveY = -move.length() * sin((move.angle() - mAngle) * PI / 180);
qreal width = delegated()->boundingRect().width() * mTotalScaleX;
qreal height = delegated()->boundingRect().height() * mTotalScaleY;
if (mOperationMode == Scaling)
{
if(!rotating())
{
mTranslateX = moveX;
// Perform the resize
if (resizingBottomRight())
{
// -----------------------------------------------------
// ! We want to keep the aspect ratio with this resize !
// -----------------------------------------------------
qreal scaleX;
qreal scaleY;
if(!mMirrorX) {
scaleX = (width + moveX) / width;
} else {
scaleX = (width - moveX) / width;
}
if(!mMirrorY) {
scaleY = (height + moveY) / height;
} else {
scaleY = (height - moveY) / height;
}
qreal scaleFactor = (scaleX + scaleY) / 2;
// Do not allow resizing of image size under frame size
if (canResizeBottomRight(width, height, scaleFactor))
{
if (mRespectRatio)
{
mScaleX = scaleFactor;
mScaleY = scaleFactor;
}
else
{
mScaleX = scaleX;
mScaleY = scaleY;
}
}
} else if (resizingLeft() || resizingRight())
{
if(width != 0) {
qreal scaleX = 0.0;
if(resizingLeft()) {
scaleX = (width - moveX) / width;
} else if(resizingRight()) {
scaleX = (width + moveX) / width;
}
if(mDelegate->isFlippable() && qAbs(scaleX) != 0) {
if((qAbs(width * scaleX)) < 2*mFrameWidth) {
bool negative = (scaleX < 0)?true:false;
if(negative) {
if(mMirrorX)
scaleX = 2*mFrameWidth/width;
else
scaleX = -2*mFrameWidth/width;
} else {
scaleX = -1;
mFlippedX = !mFlippedX;
}
}
mScaleX = scaleX;
} else if (scaleX > 1 || (width * scaleX) > 2 * mFrameWidth) {
mScaleX = scaleX;
if(resizingLeft()) {
mTranslateX = moveX;
}
}
}
} else if(resizingTop() || resizingBottom()) {
if(height != 0) {
qreal scaleY = 0.0;
if(resizingTop()) {
scaleY = (height - moveY) / height;
} else if(resizingBottom()) {
scaleY = (height + moveY) / height;
}
if(mDelegate->isFlippable() && qAbs(scaleY) != 0) {
if((qAbs(height * scaleY)) < 2*mFrameWidth) {
bool negative = (scaleY < 0)?true:false;
if(negative) {
if(mMirrorY)
scaleY = 2*mFrameWidth/width;
else
scaleY = -2*mFrameWidth/width;
} else {
scaleY = -1;
mFlippedY = !mFlippedY;
}
}
mScaleY = scaleY;
} else if (scaleY > 1 || (height * scaleY) > 2 * mFrameWidth)
{
mScaleY = scaleY;
if(resizingTop()) {
mTranslateY = moveY;
}
}
}
}
}
}
if (rotating())
{
mTranslateX = 0;
mTranslateY = 0;
QLineF startLine(sceneBoundingRect().center(), event->lastScenePos());
QLineF currentLine(sceneBoundingRect().center(), event->scenePos());
mAngle += startLine.angleTo(currentLine);
if ((int)mAngle % 45 >= 45 - mAngleTolerance || (int)mAngle % 45 <= mAngleTolerance)
{
mAngle = qRound(mAngle / 45) * 45;
mAngleOffset += startLine.angleTo(currentLine);
if ((int)mAngleOffset % 360 > mAngleTolerance && (int)mAngleOffset % 360 < 360 - mAngleTolerance)
{
mAngle += mAngleOffset;
mAngleOffset = 0;
}
}
else if ((int)mAngle % 30 >= 30 - mAngleTolerance || (int)mAngle % 30 <= mAngleTolerance)
{
mAngle = qRound(mAngle / 30) * 30;
mAngleOffset += startLine.angleTo(currentLine);
if ((int)mAngleOffset % 360 > mAngleTolerance && (int)mAngleOffset % 360 < 360 - mAngleTolerance)
{
mAngle += mAngleOffset;
mAngleOffset = 0;
}
}
setCursorFromAngle(QString::number((int)mAngle % 360));
}
else if (moving())
{
mTranslateX = move.dx();
mTranslateY = move.dy();
moveLinkedItems(move);
}
if (mOperationMode == Scaling || moving() || rotating())
{
QTransform tr = buildTransform();
if (resizingRight() || resizingBottom() || resizingBottomRight())
{
QPointF ref;
// we just detects coordinates of corner before and after scaling and then moves object at diff between them.
if (resizingBottomRight() && (mMirrorX || mMirrorY))
{
if (mFlippedX && !mMirrorX && mFlippedY)// && !mMirrorY)
{
mTranslateX += mInitialTransform.map(delegated()->boundingRect().bottomLeft()).x() - tr.map(delegated()->boundingRect().bottomLeft()).x();
mTranslateY += mInitialTransform.map(delegated()->boundingRect().bottomLeft()).y() - tr.map(delegated()->boundingRect().bottomLeft()).y();
}
else if ((mFlippedX || mMirrorX) && (mFlippedY || mMirrorY))
{
mTranslateX += mInitialTransform.map(delegated()->boundingRect().bottomRight()).x() - tr.map(delegated()->boundingRect().bottomRight()).x();
mTranslateY += mInitialTransform.map(delegated()->boundingRect().bottomRight()).y() - tr.map(delegated()->boundingRect().bottomRight()).y();
}
else if (mFlippedX || mMirrorX)
{
mTranslateX += mInitialTransform.map(delegated()->boundingRect().topRight()).x() - tr.map(delegated()->boundingRect().topRight()).x();
mTranslateY += mInitialTransform.map(delegated()->boundingRect().topRight()).y() - tr.map(delegated()->boundingRect().topRight()).y();
}
else if (mFlippedY || mMirrorY)
{
mTranslateX += mInitialTransform.map(delegated()->boundingRect().bottomLeft()).x() - tr.map(delegated()->boundingRect().bottomLeft()).x();
mTranslateY += mInitialTransform.map(delegated()->boundingRect().bottomLeft()).y() - tr.map(delegated()->boundingRect().bottomLeft()).y();
}
else
{
mTranslateX += mInitialTransform.map(delegated()->boundingRect().bottomRight()).x() - tr.map(delegated()->boundingRect().bottomRight()).x();
mTranslateY += mInitialTransform.map(delegated()->boundingRect().bottomRight()).y() - tr.map(delegated()->boundingRect().bottomRight()).y();
}
}
else
{
mTranslateX += mInitialTransform.map(delegated()->boundingRect().topLeft()).x() - tr.map(delegated()->boundingRect().topLeft()).x();
mTranslateY += mInitialTransform.map(delegated()->boundingRect().topLeft()).y() - tr.map(delegated()->boundingRect().topLeft()).y();
}
}
else if (resizingTop() || resizingLeft())
{
QPointF bottomRight = tr.map(delegated()->boundingRect().bottomRight());
QPointF fixedPoint = mInitialTransform.map(delegated()->boundingRect().bottomRight());
mTranslateX += fixedPoint.x() - bottomRight.x();
mTranslateY += fixedPoint.y() - bottomRight.y();
}
delegated()->setTransform(buildTransform());
}
else // resizing/resizing horizontally
{
if (resizingBottomRight())
{
static QSizeF incV = QSizeF();
static QSizeF incH = QSizeF();
if (mMirrorX && mMirrorY)
mCurrentTool = ResizeTop;
else
mCurrentTool = ResizeBottom;
incV = resizeDelegate(moveX, moveY);
mOriginalSize += incV;
if (mMirrorX && mMirrorY)
mCurrentTool = ResizeLeft;
else
mCurrentTool = ResizeRight;
move = QLineF(event->lastScenePos(), event->scenePos());
moveX = move.length() * cos((move.angle() - mAngle) * PI / 180);
moveY = -move.length() * sin((move.angle() - mAngle) * PI / 180);
mFixedPoint = getFixedPointFromPos();
incH = resizeDelegate(moveX, moveY);
mOriginalSize -= incV;
mOriginalSize += incH;
mCurrentTool = ResizeBottomRight;
}
else
resizeDelegate(moveX, moveY);
}
event->accept();
}
void reportValues(
const word &fieldName,
const fvMesh &mesh,
CommonValueExpressionDriver &driver,
const string &entName
) {
startLine(
mesh.time(),
entName
);
Field<Type> result(
driver.evaluate<Type>(fieldName)
);
AccumulationCalculation<Type> calculator(
result,
false,
driver
);
writeData(Info,calculator.size(),"Size | Weight Sum","size");
Info << " | ";
writeData(Info,calculator.weightSum(),"","weight_sum",true);
writeData(Info,calculator.minimum(),"Range (min-max)","minimum");
Info << " | ";
writeData(Info,calculator.maximum(),"","maximum",true);
writeData(
Info,calculator.average(),
"Average | weighted","average");
Info << " | ";
writeData(
Info,calculator.weightedAverage(),
"","average_weighted",true);
writeData(
Info,calculator.sum(),
"Sum | weighted","sum");
Info << " | ";
writeData(
Info,calculator.weightedSum(),
"","sum_weighted",true);
writeData(
Info,calculator.distribution().median(),
"Median | weighted","median");
Info << " | ";
writeData(
Info,calculator.weightedDistribution().median(),
"","median_weighted",true);
if(nrOfQuantiles) {
scalar dx=1./nrOfQuantiles;
for(label i=1;i<nrOfQuantiles;i++) {
scalar thisQuantile=dx*i;
NumericAccumulationNamedEnum::accuSpecification quant(
NumericAccumulationNamedEnum::numQuantile,
thisQuantile
);
NumericAccumulationNamedEnum::accuSpecification wquant(
NumericAccumulationNamedEnum::numWeightedQuantile,
thisQuantile
);
OStringStream annotation;
annotation << thisQuantile << " quantile | weighted";
writeData(
Info,calculator(quant),
annotation.str(),NumericAccumulationNamedEnum::toString(quant));
Info << " | ";
writeData(
Info,calculator(wquant),
"",NumericAccumulationNamedEnum::toString(wquant),true);
}
}
forAll(fractionSmallerThan,i) {
scalar value=fractionSmallerThan[i];
NumericAccumulationNamedEnum::accuSpecification smaller(
NumericAccumulationNamedEnum::numSmaller,
value
);
NumericAccumulationNamedEnum::accuSpecification wsmaller(
NumericAccumulationNamedEnum::numWeightedSmaller,
value
);
OStringStream annotation;
annotation << "x <= " << value << " | weighted";
writeData(
Info,calculator(smaller),
annotation.str(),NumericAccumulationNamedEnum::toString(smaller));
Info << " | ";
writeData(
Info,calculator(wsmaller),
"",NumericAccumulationNamedEnum::toString(wsmaller),true);
}
bool DRAWING_TOOL::drawArc( DRAWSEGMENT*& aGraphic )
{
bool clockwise = true; // drawing direction of the arc
double startAngle = 0.0f; // angle of the first arc line
VECTOR2I cursorPos = m_controls->GetCursorPosition();
DRAWSEGMENT helperLine;
helperLine.SetShape( S_SEGMENT );
helperLine.SetLayer( Dwgs_User );
helperLine.SetWidth( 1 );
// Add a VIEW_GROUP that serves as a preview for the new item
KIGFX::VIEW_GROUP preview( m_view );
m_view->Add( &preview );
m_toolMgr->RunAction( COMMON_ACTIONS::selectionClear, true );
m_controls->ShowCursor( true );
m_controls->SetSnapping( true );
Activate();
enum ARC_STEPS
{
SET_ORIGIN = 0,
SET_END,
SET_ANGLE,
FINISHED
};
int step = SET_ORIGIN;
// Main loop: keep receiving events
while( OPT_TOOL_EVENT evt = Wait() )
{
cursorPos = m_controls->GetCursorPosition();
if( evt->IsCancel() || evt->IsActivate() )
{
preview.Clear();
preview.ViewUpdate( KIGFX::VIEW_ITEM::GEOMETRY );
delete aGraphic;
aGraphic = NULL;
break;
}
else if( evt->IsClick( BUT_LEFT ) )
{
switch( step )
{
case SET_ORIGIN:
{
LAYER_ID layer = m_frame->GetScreen()->m_Active_Layer;
if( IsCopperLayer( layer ) )
{
DisplayInfoMessage( NULL, _( "Graphic not allowed on Copper layers" ) );
--step;
}
else
{
// Init the new item attributes
aGraphic->SetShape( S_ARC );
aGraphic->SetAngle( 0.0 );
aGraphic->SetWidth( getSegmentWidth( layer ) );
aGraphic->SetCenter( wxPoint( cursorPos.x, cursorPos.y ) );
aGraphic->SetLayer( layer );
helperLine.SetStart( aGraphic->GetCenter() );
helperLine.SetEnd( aGraphic->GetCenter() );
preview.Add( aGraphic );
preview.Add( &helperLine );
m_controls->SetAutoPan( true );
m_controls->CaptureCursor( true );
}
}
break;
case SET_END:
{
if( wxPoint( cursorPos.x, cursorPos.y ) != aGraphic->GetCenter() )
{
VECTOR2D startLine( aGraphic->GetArcStart() - aGraphic->GetCenter() );
startAngle = startLine.Angle();
aGraphic->SetArcStart( wxPoint( cursorPos.x, cursorPos.y ) );
}
else
--step; // one another chance to draw a proper arc
}
break;
case SET_ANGLE:
{
if( wxPoint( cursorPos.x, cursorPos.y ) != aGraphic->GetArcStart() && aGraphic->GetAngle() != 0 )
{
assert( aGraphic->GetArcStart() != aGraphic->GetArcEnd() );
assert( aGraphic->GetWidth() > 0 );
m_view->Add( aGraphic );
aGraphic->ViewUpdate( KIGFX::VIEW_ITEM::GEOMETRY );
preview.Remove( aGraphic );
preview.Remove( &helperLine );
}
else
--step; // one another chance to draw a proper arc
}
break;
}
if( ++step == FINISHED )
break;
}
else if( evt->IsMotion() )
{
switch( step )
{
case SET_END:
helperLine.SetEnd( wxPoint( cursorPos.x, cursorPos.y ) );
aGraphic->SetArcStart( wxPoint( cursorPos.x, cursorPos.y ) );
break;
case SET_ANGLE:
{
VECTOR2D endLine( wxPoint( cursorPos.x, cursorPos.y ) - aGraphic->GetCenter() );
double newAngle = RAD2DECIDEG( endLine.Angle() - startAngle );
// Adjust the new angle to (counter)clockwise setting
if( clockwise && newAngle < 0.0 )
newAngle += 3600.0;
else if( !clockwise && newAngle > 0.0 )
newAngle -= 3600.0;
aGraphic->SetAngle( newAngle );
}
break;
}
// Show a preview of the item
preview.ViewUpdate( KIGFX::VIEW_ITEM::GEOMETRY );
}
else if( evt->IsAction( &COMMON_ACTIONS::incWidth ) )
{
aGraphic->SetWidth( aGraphic->GetWidth() + WIDTH_STEP );
preview.ViewUpdate( KIGFX::VIEW_ITEM::GEOMETRY );
}
else if( evt->IsAction( &COMMON_ACTIONS::decWidth ) )
{
int width = aGraphic->GetWidth();
if( width > WIDTH_STEP )
{
aGraphic->SetWidth( width - WIDTH_STEP );
preview.ViewUpdate( KIGFX::VIEW_ITEM::GEOMETRY );
}
}
else if( evt->IsAction( &COMMON_ACTIONS::arcPosture ) )
{
if( clockwise )
aGraphic->SetAngle( aGraphic->GetAngle() - 3600.0 );
else
aGraphic->SetAngle( aGraphic->GetAngle() + 3600.0 );
clockwise = !clockwise;
preview.ViewUpdate( KIGFX::VIEW_ITEM::GEOMETRY );
}
}
m_controls->ShowCursor( false );
m_controls->SetSnapping( false );
m_controls->SetAutoPan( false );
m_controls->CaptureCursor( false );
m_view->Remove( &preview );
return ( step > SET_ORIGIN );
}
void
PrintDataBlockForGas(FILE *f, ParserState *P, int inlineAsm)
{
AST *ast;
int saveState;
if (gl_errors != 0)
return;
saveState = P->printLabelsVerbatim;
P->printLabelsVerbatim = 1;
if (inlineAsm) {
fprintf(f, "__asm__(\n");
fprintf(f, "\"\t\t.section .%s.cog, \\\"ax\\\"\\n\"\n",
P->basename);
}
/* print constant declarations */
PrintConstantsGas(f, P, inlineAsm);
if (inlineAsm) {
fprintf(f, "\"\t\t.compress off\\n\"\n");
}
startLine(f, inlineAsm);
fprintf(f, "..start");
endLine(f, inlineAsm);
for (ast = P->datblock; ast; ast = ast->right) {
/* print anything for start of line here */
startLine(f, inlineAsm);
switch (ast->kind) {
case AST_BYTELIST:
outputGasDataList(f, ".byte", ast->left);
break;
case AST_WORDLIST:
outputGasDataList(f, ".word", ast->left);
break;
case AST_LONGLIST:
outputGasDataList(f, ".long", ast->left);
break;
case AST_INSTRHOLDER:
outputGasInstruction(f, ast->left);
break;
case AST_IDENTIFIER:
outputGasLabel(f, ast);
break;
case AST_FILE:
ERROR(ast, "File directive not supported in GAS output");
break;
case AST_ORG:
outputGasDirective(f, ".org", ast->left);
break;
case AST_RES:
outputGasDirective(f, ".res", ast->left);
break;
case AST_FIT:
outputGasDirective(f, ".fit", ast->left ? ast->left : AstInteger(496));
break;
default:
ERROR(ast, "unknown element in data block");
break;
}
/* print end of line stuff here */
endLine(f, inlineAsm);
}
if (inlineAsm) {
fprintf(f, "\"\t\t.compress default\\n\"\n");
fprintf(f, "\"\t\t.text\\n\"\n");
fprintf(f, "\n);\n");
}
P->printLabelsVerbatim = saveState;
}
