CXTPChartDeviceCommand* CXTPChartRadarAxisXView::CreateTickMarksDeviceCommand(CXTPChartDeviceContext* pDC)
{
UNREFERENCED_PARAMETER(pDC);
CXTPChartDeviceCommand* pCommands = new CXTPChartHitTestElementCommand(m_pAxis, m_rcBounds);
CXTPChartAxisTickMarks* pTickMarks = m_pAxis->GetTickMarks();
if (!pTickMarks->IsVisible())
return pCommands;
CXTPChartColor clrAxis = m_pAxis->GetActualColor();
int nLength = pTickMarks->GetLength();
int nThickness = pTickMarks->GetThickness();
BOOL bMinorVisible = pTickMarks->IsMinorVisible();
BOOL bCross = pTickMarks->IsCrossAxis();
int nAxisThickness = m_pAxis->GetThickness() - 1;
int nExtraLength = bCross ? nLength + nAxisThickness : 0;
for (int i = 0; i < m_arrTicks.GetSize(); i++)
{
double lineAngle = ValueToAngle(m_arrTicks[i].m_dValue);
double cs = cos(lineAngle);
double sn = sin(lineAngle);
CXTPChartPointF startPoint(m_ptCenter.X + (m_nRadius - nExtraLength) * cs, m_ptCenter.Y - (m_nRadius - nExtraLength) * sn);
CXTPChartPointF finishPoint(m_ptCenter.X + (m_nRadius + nAxisThickness + nLength) * cs, m_ptCenter.Y - (m_nRadius + nAxisThickness + nLength) * sn);
pCommands->AddChildCommand(new CXTPChartSolidLineDeviceCommand(startPoint, finishPoint, clrAxis, nThickness));
}
if (bMinorVisible && !IsPolygonDiagramStyle())
{
nLength = pTickMarks->GetMinorLength();
int nExtraLength = bCross ? nLength + nAxisThickness : 0;
int nMinorThickness = pTickMarks->GetMinorThickness();
for (int i = 0; i < m_arrMinorTicks.GetSize(); i++)
{
double lineAngle = ValueToAngle(m_arrMinorTicks[i]);
double cs = cos(lineAngle);
double sn = sin(lineAngle);
CXTPChartPointF startPoint(m_ptCenter.X + (m_nRadius - nExtraLength) * cs, m_ptCenter.Y - (m_nRadius - nExtraLength) * sn);
CXTPChartPointF finishPoint(m_ptCenter.X + (m_nRadius + nAxisThickness + nLength) * cs, m_ptCenter.Y - (m_nRadius + nAxisThickness + nLength) * sn);
pCommands->AddChildCommand(new CXTPChartSolidLineDeviceCommand(startPoint, finishPoint, clrAxis, nMinorThickness));
}
}
return pCommands;
}
void CXTPChartRadarAxisXView::CreateTickMarks(CXTPChartDeviceContext* pDC)
{
UNREFERENCED_PARAMETER(pDC);
m_arrTicks.RemoveAll();
m_arrMinorTicks.RemoveAll();
double dAxisMinValue = m_dMinValue;
double dAxisMaxValue = m_dMaxValue;
double dGridSpacing = GetGridSpacing();
int nOffset = m_pAxis->GetThickness() + (m_pAxis->GetTickMarks()->IsVisible() ? m_pAxis->GetTickMarks()->GetLength() : 0);
if (m_pAxis->GetCustomLabels()->GetCount() > 0)
{
CXTPChartAxisCustomLabels* pCustomLabels = m_pAxis->GetCustomLabels();
int nCount = pCustomLabels->GetCount();
for (int i = 0; i < nCount; i++)
{
CXTPChartAxisCustomLabel* pLabel = pCustomLabels->GetAt(i);
CXTPChartRadarAxisXViewTick tick;
tick.m_dValue = !pLabel->GetAxisValue().IsEmpty() ? m_pAxis->GetScaleTypeMap()->ValueToInternal(pLabel->GetAxisValue()) :
pLabel->GetAxisValueInternal();
if (tick.m_dValue >= dAxisMinValue && tick.m_dValue <= dAxisMaxValue)
{
tick.m_strLabel = pLabel->GetText();
CXTPChartTextPainter painter(pDC, tick.m_strLabel, m_pAxis->GetLabel());
tick.m_szLabel = painter.GetSize();
tick.m_szBounds = painter.GetRoundedBounds().Size();
double lineAngle = ValueToAngle(tick.m_dValue);
CXTPChartSizeF size = painter.GetSize();
CXTPChartPointF startPoint(m_ptCenter.X + m_nRadius * cos(lineAngle), m_ptCenter.Y - m_nRadius * sin(lineAngle));
CXTPChartPointF finishPoint(startPoint.X + (float)(cos(lineAngle) * nOffset), startPoint.Y - (float)(sin(lineAngle) * nOffset));
CXTPChartRectF innerBounds;
CXTPChartSeriesLabelConnectorPainterBase::CalcBorderBoundsForTangentDrawing(finishPoint, lineAngle, size, 0, innerBounds);
innerBounds.Round();
tick.m_ptLocation = innerBounds.GetLocation();
m_arrTicks.Add(tick);
}
}
}
else
{
double dMark = m_dMinValue;
while (dMark < dAxisMaxValue - CXTPChartMathUtils::m_dEPS)
{
CXTPChartRadarAxisXViewTick tick;
tick.m_dValue = AxisToValue(dMark);
tick.m_strLabel = m_pAxis->GetScaleTypeMap()->InternalToValue(m_pAxis->GetLabel()->GetFormat(), tick.m_dValue);
CXTPChartTextPainter painter(pDC, tick.m_strLabel, m_pAxis->GetLabel());
tick.m_szLabel = painter.GetSize();
tick.m_szBounds = painter.GetRoundedBounds().Size();
double lineAngle = ValueToAngle(tick.m_dValue);
CXTPChartSizeF size = painter.GetSize();
CXTPChartPointF startPoint(m_ptCenter.X + m_nRadius * cos(lineAngle), m_ptCenter.Y - m_nRadius * sin(lineAngle));
CXTPChartPointF finishPoint(startPoint.X + (float)(cos(lineAngle) * nOffset), startPoint.Y - (float)(sin(lineAngle) * nOffset));
CXTPChartRectF innerBounds;
CXTPChartSeriesLabelConnectorPainterBase::CalcBorderBoundsForTangentDrawing(finishPoint, lineAngle, size, 0, innerBounds);
innerBounds.Round();
tick.m_ptLocation = innerBounds.GetLocation();
m_arrTicks.Add(tick);
dMark += dGridSpacing;
}
int nMinorCount = m_pAxis->GetMinorCount();
if (m_arrTicks.GetSize() > 0 && nMinorCount > 0)
{
double cur, prev;
for (int i = 0; i <= m_arrTicks.GetSize(); i++)
{
if (m_pAxis->IsLogarithmic())
{
cur = i == m_arrTicks.GetSize() ? m_arrTicks[i - 1].m_dValue * m_pAxis->GetLogarithmicBase() :
m_arrTicks[i].m_dValue;
prev = i == 0 ? m_arrTicks[0].m_dValue / m_pAxis->GetLogarithmicBase() : m_arrTicks[i - 1].m_dValue;
}
else
{
cur = i == m_arrTicks.GetSize() ? m_arrTicks[i - 1].m_dValue + dGridSpacing : m_arrTicks[i].m_dValue;
prev = i == 0 ? cur - dGridSpacing : m_arrTicks[i - 1].m_dValue;
}
for (int j = 0; j < nMinorCount; j++)
{
double dValue = prev + (cur - prev) * (j + 1) / (nMinorCount + 1);
if (dValue >= dAxisMinValue && dValue <= dAxisMaxValue)
{
m_arrMinorTicks.Add(dValue);
}
}
}
}
}
if (GetAxis()->IsVisible() && GetAxis()->GetLabel()->IsVisible())
{
CXTPChartRadarDiagramView* pDiagramView = GetDiagramView();
for (int i = 0; i < m_arrTicks.GetSize(); i++)
{
CXTPChartRectF rc(m_arrTicks[i].m_ptLocation, m_arrTicks[i].m_szLabel);
pDiagramView->CheckLabelBounds(rc);
}
}
}
bool Parser::readRecord( QDataStream &stream )
{
if ( ! mOutput ) {
qWarning() << "Output device not set";
return false;
}
quint32 type;
quint32 size;
stream >> type;
stream >> size;
{
QString name;
if (0 < type && type <= EMR_LASTRECORD)
name = EmfRecords[type].name;
else
name = "(out of bounds)";
#if DEBUG_EMFPARSER
kDebug(31000) << "Record length" << size << "type " << hex << type << "(" << dec << type << ")" << name;
#endif
}
#if DEBUG_EMFPARSER == 2
soakBytes(stream, size - 8);
#else
switch ( type ) {
case EMR_POLYLINE:
{
QRect bounds;
stream >> bounds;
quint32 count;
stream >> count;
QList<QPoint> aPoints;
for (quint32 i = 0; i < count; ++i) {
QPoint point;
stream >> point;
aPoints.append( point );
}
mOutput->polyLine( bounds, aPoints );
}
break;
case EMR_SETWINDOWEXTEX:
{
QSize size;
//stream >> size;
qint32 width, height;
stream >> width >> height;
//kDebug(31000) << "SETWINDOWEXTEX" << width << height;
size = QSize(width, height);
mOutput->setWindowExtEx( size );
}
break;
case EMR_SETWINDOWORGEX:
{
QPoint origin;
stream >> origin;
mOutput->setWindowOrgEx( origin );
}
break;
case EMR_SETVIEWPORTEXTEX:
{
QSize size;
stream >> size;
mOutput->setViewportExtEx( size );
}
break;
case EMR_SETVIEWPORTORGEX:
{
QPoint origin;
stream >> origin;
mOutput->setViewportOrgEx( origin );
}
break;
case EMR_SETBRUSHORGEX:
{
QPoint origin;
stream >> origin;
#if DEBUG_EMFPARSER
kDebug(33100) << "EMR_SETBRUSHORGEX" << origin;
#endif
}
break;
case EMR_EOF:
{
mOutput->eof();
soakBytes( stream, size-8 ); // because we already took 8.
return false;
}
break;
case EMR_SETPIXELV:
{
QPoint point;
quint8 red, green, blue, reserved;
stream >> point;
stream >> red >> green >> blue >> reserved;
mOutput->setPixelV( point, red, green, blue, reserved );
}
break;
case EMR_SETMAPMODE:
{
quint32 mapMode;
stream >> mapMode;
mOutput->setMapMode( mapMode );
}
break;
case EMR_SETBKMODE:
{
quint32 backgroundMode;
stream >> backgroundMode;
mOutput->setBkMode( backgroundMode );
}
break;
case EMR_SETPOLYFILLMODE:
{
quint32 PolygonFillMode;
stream >> PolygonFillMode;
mOutput->setPolyFillMode( PolygonFillMode );
}
break;
case EMR_SETROP2:
{
quint32 ROP2Mode;
stream >> ROP2Mode;
//kDebug(33100) << "EMR_SETROP2" << ROP2Mode;
}
break;
case EMR_SETSTRETCHBLTMODE:
{
quint32 stretchMode;
stream >> stretchMode;
mOutput->setStretchBltMode( stretchMode );
}
break;
case EMR_SETTEXTALIGN:
{
quint32 textAlignMode;
stream >> textAlignMode;
mOutput->setTextAlign( textAlignMode );
}
break;
case EMR_SETTEXTCOLOR:
{
quint8 red, green, blue, reserved;
stream >> red >> green >> blue >> reserved;
mOutput->setTextColor( red, green, blue, reserved );
}
break;
case EMR_SETBKCOLOR:
{
quint8 red, green, blue, reserved;
stream >> red >> green >> blue >> reserved;
mOutput->setBkColor( red, green, blue, reserved );
}
break;
case EMR_MOVETOEX:
{
quint32 x, y;
stream >> x >> y;
mOutput->moveToEx( x, y );
//kDebug(33100) << "xx EMR_MOVETOEX" << x << y;
}
break;
case EMR_SETMETARGN:
{
// Takes no arguments
mOutput->setMetaRgn();
}
break;
case EMR_INTERSECTCLIPRECT:
{
QRect clip;
stream >> clip;
//kDebug(33100) << "EMR_INTERSECTCLIPRECT" << clip;
}
break;
case EMR_SAVEDC:
{
mOutput->saveDC();
}
break;
case EMR_RESTOREDC:
{
qint32 savedDC;
stream >> savedDC;
mOutput->restoreDC( savedDC );
}
break;
case EMR_SETWORLDTRANSFORM:
{
stream.setFloatingPointPrecision(QDataStream::SinglePrecision);
float M11, M12, M21, M22, Dx, Dy;
stream >> M11;
stream >> M12;
stream >> M21;
stream >> M22;
stream >> Dx;
stream >> Dy;
//kDebug(31000) << "Set world transform" << M11 << M12 << M21 << M22 << Dx << Dy;
mOutput->setWorldTransform( M11, M12, M21, M22, Dx, Dy );
}
break;
case EMR_MODIFYWORLDTRANSFORM:
{
stream.setFloatingPointPrecision(QDataStream::SinglePrecision);
float M11, M12, M21, M22, Dx, Dy;
stream >> M11;
stream >> M12;
stream >> M21;
stream >> M22;
stream >> Dx;
stream >> Dy;
//kDebug(31000) << "stream position after the matrix: " << stream.device()->pos();
quint32 ModifyWorldTransformMode;
stream >> ModifyWorldTransformMode;
mOutput->modifyWorldTransform( ModifyWorldTransformMode, M11, M12,
M21, M22, Dx, Dy );
}
break;
case EMR_SELECTOBJECT:
quint32 ihObject;
stream >> ihObject;
mOutput->selectObject( ihObject );
break;
case EMR_CREATEPEN:
{
quint32 ihPen;
stream >> ihPen;
quint32 penStyle;
stream >> penStyle;
quint32 x, y;
stream >> x;
stream >> y; // unused
quint8 red, green, blue, reserved;
stream >> red >> green >> blue;
stream >> reserved; // unused;
mOutput->createPen( ihPen, penStyle, x, y, red, green, blue, reserved );
break;
}
case EMR_CREATEBRUSHINDIRECT:
{
quint32 ihBrush;
stream >> ihBrush;
quint32 BrushStyle;
stream >> BrushStyle;
quint8 red, green, blue, reserved;
stream >> red >> green >> blue;
stream >> reserved; // unused;
quint32 BrushHatch;
stream >> BrushHatch;
mOutput->createBrushIndirect( ihBrush, BrushStyle, red, green, blue, reserved, BrushHatch );
break;
}
case EMR_DELETEOBJECT:
{
quint32 ihObject;
stream >> ihObject;
mOutput->deleteObject( ihObject );
}
break;
case EMR_ELLIPSE:
{
QRect box;
stream >> box;
mOutput->ellipse( box );
}
break;
case EMR_RECTANGLE:
{
QRect box;
stream >> box;
mOutput->rectangle( box );
//kDebug(33100) << "xx EMR_RECTANGLE" << box;
}
break;
case EMR_ARC:
{
QRect box;
QPoint start, end;
stream >> box;
stream >> start >> end;
mOutput->arc( box, start, end );
}
break;
case EMR_CHORD:
{
QRect box;
QPoint start, end;
stream >> box;
stream >> start >> end;
mOutput->chord( box, start, end );
}
break;
case EMR_PIE:
{
QRect box;
QPoint start, end;
stream >> box;
stream >> start >> end;
mOutput->pie( box, start, end );
}
break;
case EMR_SELECTPALLETTE:
{
quint32 ihPal;
stream >> ihPal;
#if DEBUG_EMFPARSER
kDebug(33100) << "EMR_SELECTPALLETTE" << ihPal;
#endif
}
break;
case EMR_SETMITERLIMIT:
{
stream.setFloatingPointPrecision(QDataStream::SinglePrecision);
float miterLimit;
stream >> miterLimit;
#if DEBUG_EMFPARSER
kDebug(33100) << "EMR_SETMITERLIMIT" << miterLimit;
#endif
}
break;
case EMR_BEGINPATH:
mOutput->beginPath();
break;
case EMR_ENDPATH:
mOutput->endPath();
break;
case EMR_CLOSEFIGURE:
mOutput->closeFigure();
break;
case EMR_FILLPATH:
{
QRect bounds;
stream >> bounds;
mOutput->fillPath( bounds );
//kDebug(33100) << "xx EMR_FILLPATH" << bounds;
}
break;
case EMR_STROKEANDFILLPATH:
{
QRect bounds;
stream >> bounds;
mOutput->strokeAndFillPath( bounds );
//kDebug(33100) << "xx EMR_STROKEANDFILLPATHPATH" << bounds;
}
break;
case EMR_STROKEPATH:
{
QRect bounds;
stream >> bounds;
mOutput->strokePath( bounds );
//kDebug(33100) << "xx EMR_STROKEPATH" << bounds;
}
break;
case EMR_SETCLIPPATH:
{
quint32 regionMode;
stream >> regionMode;
mOutput->setClipPath( regionMode );
}
break;
case EMR_LINETO:
{
quint32 x, y;
stream >> x >> y;
QPoint finishPoint( x, y );
mOutput->lineTo( finishPoint );
//kDebug(33100) << "xx EMR_LINETO" << x << y;
}
break;
case EMR_ARCTO:
{
QRect box;
stream >> box;
QPoint start;
stream >> start;
QPoint end;
stream >> end;
mOutput->arcTo( box, start, end );
}
break;
case EMR_COMMENT:
{
quint32 dataSize;
stream >> dataSize;
quint32 maybeIdentifier;
stream >> maybeIdentifier;
if ( maybeIdentifier == 0x2B464D45 ) {
// EMFPLUS
//kDebug(33100) << "EMR_COMMENT_EMFPLUS";
soakBytes( stream, size-16 ); // because we already took 16.
} else if ( maybeIdentifier == 0x00000000 ) {
//kDebug(33100) << "EMR_EMFSPOOL";
soakBytes( stream, size-16 ); // because we already took 16.
} else if ( maybeIdentifier == 0x43494447 ) {
quint32 commentType;
stream >> commentType;
//kDebug(33100) << "EMR_COMMENT_PUBLIC" << commentType;
soakBytes( stream, size-20 ); // because we already took 20.
} else {
//kDebug(33100) << "EMR_COMMENT" << dataSize << maybeIdentifier;
soakBytes( stream, size-16 ); // because we already took 16.
}
}
