void CDC::DrawExtrusion(const CRect& rRect)
{
// Draw highlight.
Pen(GetSysColor(COLOR_BTNHIGHLIGHT));
Move(rRect.left, rRect.bottom-1);
Line(rRect.left, rRect.top);
Line(rRect.right-1, rRect.top);
// Draw shadow.
Pen(GetSysColor(COLOR_BTNSHADOW));
Line(rRect.right-1, rRect.bottom-1);
Line(rRect.left, rRect.bottom-1);
}
void CDC::DrawBtnDownBorder(const CRect& rRect)
{
// Draw the surrounding border.
Pen(RGB(0,0,0));
Line(rRect.left+1, rRect.top, rRect.right-1, rRect.top);
Line(rRect.left, rRect.top+1, rRect.left, rRect.bottom-1);
Line(rRect.right-1, rRect.top+1, rRect.right-1, rRect.bottom-1);
Line(rRect.left+1, rRect.bottom-1, rRect.right-1, rRect.bottom-1);
// Draw the 3D lighting.
Pen(GetSysColor(COLOR_BTNSHADOW));
Line(rRect.left+1, rRect.top+1, rRect.right-1, rRect.top+1);
Line(rRect.left+1, rRect.top+1, rRect.left+1, rRect.bottom-1);
}
void CPropPageFrameDefault::FillGradientRectH(CDC *pDc, const RECT &rect, COLORREF clrLeft, COLORREF clrRight)
{
// pre calculation
int nSteps = rect.right-rect.left;
int nRRange = GetRValue(clrRight)-GetRValue(clrLeft);
int nGRange = GetGValue(clrRight)-GetGValue(clrLeft);
int nBRange = GetBValue(clrRight)-GetBValue(clrLeft);
double dRStep = (double)nRRange/(double)nSteps;
double dGStep = (double)nGRange/(double)nSteps;
double dBStep = (double)nBRange/(double)nSteps;
double dR = (double)GetRValue(clrLeft);
double dG = (double)GetGValue(clrLeft);
double dB = (double)GetBValue(clrLeft);
CPen *pPrevPen = NULL;
for (int x = rect.left; x <= rect.right; ++x)
{
CPen Pen(PS_SOLID, 1, RGB((BYTE)dR, (BYTE)dG, (BYTE)dB));
pPrevPen = pDc->SelectObject(&Pen);
pDc->MoveTo(x, rect.top);
pDc->LineTo(x, rect.bottom);
pDc->SelectObject(pPrevPen);
dR+= dRStep;
dG+= dGStep;
dB+= dBStep;
}
}
void LKSurface::DrawLine(Pen::Style PenStyle, const int width, const POINT& ptStart, const POINT& ptEnd, const LKColor& cr, const RECT& rc) {
LKPen Pen(PenStyle, width, cr);
const auto OldPen = SelectObject(Pen);
const POINT pt[2] = {ptStart, ptEnd};
Polyline(pt, 2, rc);
SelectObject(OldPen);
}
void crobot::Refresh()
{
QPen Pen(Qt::black, 5);
pType->setRect(-(315/2),-(330/2),315,330);
pType->setRotation(-nAngle);
pType->setPos(nX,nY);
pType->setPen(Pen);
}
//
// This draws the background of a toolbar
//
void ToolBar::OnPaint( wxPaintEvent & event )
{
wxPaintDC dc( (wxWindow *) event.GetEventObject() );
// Start with a clean background
//
// Under GTK, we specifically set the toolbar background to the background
// colour in the system theme.
#if defined( __WXGTK__ )
dc.SetBackground( wxBrush( wxSystemSettings::GetColour( wxSYS_COLOUR_BACKGROUND ) ) );
#endif
dc.Clear();
// EXPERIMENTAL_THEMING is set to not apply the gradient
// on wxMAC builds. on wxMAC we have the AQUA_THEME.
#ifdef USE_AQUA_THEME
Repaint( &dc );
#else
#ifdef EXPERIMENTAL_THEMING
wxImage * mpBackGradient = &theTheme.Image( bmpRecoloredUpLarge );
if( mpBackGradient != NULL )
{
wxSize imSz( mpBackGradient->GetWidth(), mpBackGradient->GetHeight() );
wxSize sz = GetSize();
int y;
for(y=0;y<sz.y;y++)
{
int yPix = ((float)y * imSz.y - 1.0f)/(sz.y-1);
wxColour col(
mpBackGradient->GetRed( 0, yPix),
mpBackGradient->GetGreen( 0, yPix),
mpBackGradient->GetBlue( 0, yPix));
// Set background colour so that controls placed on this
// toolbar such as radio buttons will draw reasonably.
// It's a little tacky setting the background colour
// here, but we can't do it in the constructor as the gradient
// may not be available yet.
// Better than this would be to set the colour when the image
// is loaded.
// We use the colour at the half way point as a suitable 'average'.
if( y==(sz.y/2) )
{
SetBackgroundColour( col );
}
wxPen Pen( col );
dc.SetPen(Pen );
AColor::Line(dc, 0, y, sz.x, y );
}
}
#endif
#endif
}
/**
* Test a keyhole.
*/
void notestKeyhole()
{
TS_TRACE("Canvas DrawKeyhole");
int argc = 0;
QApplication app(argc, (char **)nullptr, 0);
Canvas c;
Pen(Pen::SOLID, 1, Color(0, 0, 0));
Brush(Color(128, 128, 0));
c.DrawKeyhole(0, 0, 10, 20, Angle::Degrees(-10), Angle::Degrees(10));
c.show();
app.exec();
}
void CDC::DrawBtnUpBorder(const CRect& rRect)
{
// Draw the surrounding border.
Pen(RGB(0,0,0));
Line(rRect.left+1, rRect.top, rRect.right-1, rRect.top);
Line(rRect.left, rRect.top+1, rRect.left, rRect.bottom-1);
Line(rRect.right-1, rRect.top+1, rRect.right-1, rRect.bottom-1);
Line(rRect.left+1, rRect.bottom-1, rRect.right-1, rRect.bottom-1);
// Draw the 3D lighting.
DrawExtrusion(CRect(rRect.left+1, rRect.top+1, rRect.right-1, rRect.bottom-1));
}
void DrawLine(POINT OrgPt,POINT EndPt,CDC* pDC,COLORREF ColorRef,
double Zoom)
{
int W = (int)Zoom;
if (W < 1) W = 1;
CPen Pen(PS_SOLID,W,ColorRef);
CPen* pOldPen = (CPen*)pDC->SelectObject(&Pen);
DrawLine(OrgPt,EndPt,pDC);
pDC->SelectObject(pOldPen);
}
void DrawItemShape::OnPaint( Graphics &g )
{
if(isChangeRegion())
{
ResetRegion();
}
auto region = getRegion();
SolidBrush brush(DrawTools::ColorNormal);
if (m_isFillPath)
{
if (StateNormal == m_state)
{
g.FillRegion(&brush, region.get());
}
else if (StateHovered == m_state)
{
g.FillRegion(&SolidBrush(DrawTools::ColorHovered), region.get());
}
else if (StateDisable == m_state)
{
g.FillRegion(&SolidBrush(DrawTools::ColorDisable), region.get());
}
else if (StateDown == m_state)
{
g.FillRegion(&SolidBrush(DrawTools::ColorDown), region.get());
}
else if (StateError == m_state)
{
g.FillRegion(&SolidBrush(DrawTools::ColorError), region.get());
}
else
{
g.FillRegion(&SolidBrush(m_fillColor), region.get());
}
}
if (m_isDrawPath)
{
GraphicsPath path;
path.StartFigure();
for(auto itter = m_lines.begin();itter != m_lines.end() ; itter++ )
{
(*itter)->getPath(path);
}
path.CloseFigure();
g.DrawPath(&Pen(m_drawColor),&path);
}
}
void CurveBrush::strokePens(QPointF pi1, QPointF pi2, KisPainter &/*painter*/)
{
if (m_pens.isEmpty()) {
m_pens.append(Pen(pi1, 0.0, 1.0));
}
qreal dx = pi2.x() - pi1.x();
qreal dy = pi2.y() - pi1.y();
for (int i = 0; i < m_pens.length(); i++) {
Pen &pen = m_pens[i];
QPointF endPoint(dx, dy);
QPainterPath path;
path.moveTo(0, 0);
path.lineTo(dx, dy);
QTransform transform;
transform.reset();
transform.translate(pen.pos.x(), pen.pos.y());
transform.scale(pen.scale, pen.scale);
transform.rotate(pen.rotation);
path = transform.map(path);
//m_painter->drawPainterPath(path, QPen(Qt::white, 1.0));
endPoint = transform.map(endPoint);
m_painter->drawThickLine(pen.pos, endPoint, 1.0, 1.0);
pen.pos = endPoint;
}
qreal branchThreshold = 0.5;
if ((m_branch * drand48() > branchThreshold) && (m_pens.length() < 1024)) {
int index = floor(drand48() * (m_pens.length() - 1));
m_newPen.pos = m_pens.at(index).pos;
m_newPen.rotation = drand48() * M_PI / 32; //atan(dy/dx) + (drand48() - 0.5) * M_PI/32;
m_newPen.scale = drand48() * m_pens.at(index).scale;
m_pens.append(m_newPen);
dbgKrita << m_pens.length();
m_branch = 0;
}
else {
m_branch++;
}
}
void CPaintDlg::DrawObject(int x, int y, int type)
{
COLORREF color;
if (type == OBJ_CHARGER)
color = RGB(0,0,255);
else //type == OBJ_TECH
color = RGB(255,0,0);
CClientDC dc(this);
GetClientRect(&DrawArea);
CPen Pen(PS_SOLID,2,color);
dc.SelectObject(Pen);
int side = DrawArea.bottom/n;
dc.MoveTo(x*side+1,y*side+1);
dc.LineTo(x*side+side,y*side+side);
dc.MoveTo(x*side+1,y*side+side);
dc.LineTo(x*side+side,y*side+1);
}
void Text::draw(Painter* p) const
{
Font f = style().font(spatium());
p->drawText(f, QPointF(), _text);
#if 0
QAbstractTextDocumentLayout::PaintContext c;
c.cursorPosition = -1;
if (cursor && !(score() && score()->printing())) {
if (cursor->hasSelection()) {
QAbstractTextDocumentLayout::Selection selection;
selection.cursor = *cursor;
selection.format.setBackground(c.palette.brush(QPalette::Active, QPalette::Highlight));
selection.format.setForeground(c.palette.brush(QPalette::Active, QPalette::HighlightedText));
c.selections.append(selection);
}
c.cursorPosition = cursor->position();
}
Color color = p->pen().color();
c.palette.setColor(QPalette::Text, color);
_doc->documentLayout()->draw(p->painter(), c);
// draw frame
if (hasFrame()) {
Color color(frameColor());
if (!visible())
color = Qt::gray;
else if (selected())
color = preferences.selectColor[track() == -1 ? 0 : voice()];
p->setPen(Pen(QBrush(color), frameWidth() * DPMM));
p->setBrush(QBrush(Qt::NoBrush));
if (circle())
p->drawArc(frame, 0, 5760);
else {
int r2 = frameRound() * lrint((frame.width() / frame.height()));
if (r2 > 99)
r2 = 99;
p->drawRoundRect(frame, frameRound(), r2);
}
}
#endif
}
void wxPendulumDlg::wxPendulumDlgPaint(wxPaintEvent& WXUNUSED(event))
{
SetBackgroundStyle(wxBG_STYLE_CUSTOM);
wxBufferedPaintDC dc(this);
// Get window dimensions
wxSize sz = GetClientSize();
// determine the center of the canvas
const wxPoint center(wxPoint(sz.x / 2, sz.y / 2));
// create background color
wxColour powderblue = wxColour(176,224,230);
// draw powderblue background
dc.SetPen(powderblue);
dc.SetBrush(powderblue);
dc.DrawRectangle(0, 0, sz.x, sz.y);
// draw lines
wxPen Pen(*wxBLACK_PEN);
Pen.SetWidth(1);
dc.SetPen(Pen);
dc.SetBrush(*wxBLACK_BRUSH);
double angleAccel, dt = 0.15;
angleAccel = (-9.81 / m_uiLength) * sin(m_Angle);
m_AngleVelocity += angleAccel * dt;
m_Angle += m_AngleVelocity * dt;
int anchorX = sz.x / 2, anchorY = sz.y / 4;
int ballX = anchorX + (int)(sin(m_Angle) * m_uiLength);
int ballY = anchorY + (int)(cos(m_Angle) * m_uiLength);
dc.DrawLine(anchorX, anchorY, ballX, ballY);
dc.SetBrush(*wxGREY_BRUSH);
dc.DrawEllipse(anchorX - 3, anchorY - 4, 7, 7);
dc.SetBrush(wxColour(255,255,0)); // yellow
dc.DrawEllipse(ballX - 7, ballY - 7, 20, 20);
}
void CGradientStatic::DrawHorizontalGradient()
{
double dblRstep = (GetRValue(m_crColorRT) - GetRValue(m_crColorLB)) / static_cast<double>(m_Mem.cx);
double dblGstep = (GetGValue(m_crColorRT) - GetGValue(m_crColorLB)) / static_cast<double>(m_Mem.cx);
double dblBstep = (GetBValue(m_crColorRT) - GetBValue(m_crColorLB)) / static_cast<double>(m_Mem.cx);
double r = GetRValue(m_crColorLB);
double g = GetGValue(m_crColorLB);
double b = GetBValue(m_crColorLB);
for(int x = 0; x < m_Mem.cx; x++)
{
CPen Pen(PS_SOLID, 1, RGB(r,g,b));
CPen* pOld = m_Mem.dc.SelectObject(&Pen);
m_Mem.dc.MoveTo(x,0);
m_Mem.dc.LineTo(x,m_Mem.cy);
m_Mem.dc.SelectObject(pOld);
r += dblRstep;
g += dblGstep;
b += dblBstep;
}
}
void CGradientStatic::DrawVerticalGradient()
{
double dblRstep = (GetRValue(m_crColorLB) - GetRValue(m_crColorRT)) / static_cast<double>(m_Mem.cy);
double dblGstep = (GetGValue(m_crColorLB) - GetGValue(m_crColorRT)) / static_cast<double>(m_Mem.cy);
double dblBstep = (GetBValue(m_crColorLB) - GetBValue(m_crColorRT)) / static_cast<double>(m_Mem.cy);
double r = GetRValue(m_crColorRT);
double g = GetGValue(m_crColorRT);
double b = GetBValue(m_crColorRT);
for(int y = 0; y < m_Mem.cy; y++)
{
CPen Pen(PS_SOLID, 1, RGB(r,g,b)), *pOld;
pOld = m_Mem.dc.SelectObject(&Pen);
m_Mem.dc.MoveTo(0,y);
m_Mem.dc.LineTo(m_Mem.cx,y);
m_Mem.dc.SelectObject(pOld);
r += dblRstep;
g += dblGstep;
b += dblBstep;
}
}
void FrameView::addShape( const QVector<QPoint>& Shape )
{
for(qint16 pointIndex(0); pointIndex < Shape.size(); pointIndex++)
{
Qt::GlobalColor color(getPointColorByIndex(pointIndex+1));
QPen Pen(color);
QList<QGraphicsItem*> pointGroupList;
QGraphicsLineItem* line1(new QGraphicsLineItem(-POINT_SIZE, 0, POINT_SIZE, 0));
line1->setPen(Pen);
pointGroupList.push_back(line1);
QGraphicsLineItem* line2(new QGraphicsLineItem(0, -POINT_SIZE, 0, POINT_SIZE));
line2->setPen(Pen);
pointGroupList.push_back(line2);
QGraphicsTextItem* label(new QGraphicsTextItem(QString::number(pointIndex)));
label->setDefaultTextColor(color);
label->setFont(POINT_TEXT_FONT);
label->setPos(-2*POINT_SIZE, -2.5f*POINT_SIZE);
pointGroupList.push_back(label);
QGraphicsItemGroup* pointGroup = Scene->createItemGroup(pointGroupList);
pointGroup->setPos(QPointF(Shape[pointIndex]) * Scale);
}
}
void DrawArrow(POINT OrgPt,POINT EndPt,CDC* pDC,COLORREF ColorRef,double Zoom)
{
//(EndPt.x)++;
//(EndPt.y)++;
int W = (int)Zoom;
if (W < 1) W = 1;
int H = (int)(10 * Zoom);
int L = (int)( 3 * Zoom);
CPen Pen(PS_SOLID,W,ColorRef);
CBrush Brush(ColorRef);
CPen* pOldPen = (CPen*)pDC->SelectObject(&Pen);
CBrush* pOldBrush = (CBrush*)pDC->SelectObject(&Brush);
DrawArrow(OrgPt,EndPt,H,L,pDC);
pDC->SelectObject(pOldPen);
pDC->SelectObject(pOldBrush);
}
BOOL CTreeListColumnDragWnd::DrawDragWnd( CDC* pDC )
{
// draw drag window
CRect rcItem;
GetClientRect( &rcItem );
pDC->FillSolidRect( &rcItem, m_pTreeListCtrl->m_crBkColor );
CPen Pen( PS_SOLID, 1, m_pTreeListCtrl->m_crGrid );
CPen* pOldPen = pDC->SelectObject( &Pen );
CFont* pOldFont = pDC->SelectObject( &m_pTreeListCtrl->m_Font );
int nOldMode = pDC->SetBkMode( TRANSPARENT );
ASSERT( m_pTreeListCtrl->m_arSelects.GetSize() > 0 );
CTreeListItem* pShowItem = (CTreeListItem*)m_pTreeListCtrl->m_arSelects[0];
DrawItem( pDC, rcItem, pShowItem );
pDC->SetBkMode( nOldMode );
pDC->SelectObject( pOldFont );
pDC->SelectObject( pOldPen );
return TRUE;
}
void SelectWhitePen() {
pen = Pen(1, COLOR_WHITE);
}
//------------------------------------------------------------------------------
int
main(int argc, char *argv[])
{
QApplication app(argc, argv);
Canvas c;
Pen(Pen::SOLID, 1, Color(0, 0, 0));
{
c.Select(Brush(Color(128, 128, 0, Color::TRANSPARENT)));
c.DrawKeyhole(200, 100, 50, 100, Angle::Degrees(-20), Angle::Degrees(20));
c.DrawKeyhole(400, 100, 50, 100, Angle::Degrees(70), Angle::Degrees(110));
c.DrawKeyhole(200, 300, 50, 100, Angle::Degrees(160), Angle::Degrees(200));
c.DrawKeyhole(400, 300, 50, 100, Angle::Degrees(-110), Angle::Degrees(-70));
c.show();
app.exec();
}
{
c.Clear();
c.DrawKeyhole(200, 100, 50, 100, Angle::Degrees(35), Angle::Degrees(55));
c.DrawKeyhole(400, 100, 50, 100, Angle::Degrees(125), Angle::Degrees(145));
c.DrawKeyhole(200, 300, 50, 100, Angle::Degrees(215), Angle::Degrees(235));
c.DrawKeyhole(400, 300, 50, 100, Angle::Degrees(305), Angle::Degrees(325));
c.show();
app.exec();
}
{
c.Clear();
c.DrawFilledRectangle(0, 0, 100, 100, Color(128, 128, 128,
Color::TRANSPARENT));
c.DrawFilledRectangle(100, 100, 200, 200, Color(128, 0, 0,
Color::TRANSPARENT));
c.DrawFilledRectangle(150, 150, 250, 250, Color(0, 128, 0,
Color::TRANSPARENT));
c.DrawFilledRectangle(200, 200, 300, 300, Color(0, 0, 128,
Color::TRANSPARENT));
c.DrawTransparentText(0, 0, "0");
c.DrawTransparentText(0, 100, "100");
c.DrawTransparentText(0, 200, "200");
c.DrawTransparentText(0, 300, "300");
c.DrawTransparentText(0, 400, "400");
c.DrawTransparentText(0, 500, "500");
c.DrawTransparentText(100, c.GetFontHeight(), "100");
c.DrawTransparentText(200, c.GetFontHeight(), "200");
c.DrawTransparentText(300, c.GetFontHeight(), "300");
c.DrawTransparentText(400, c.GetFontHeight(), "400");
c.DrawTransparentText(500, c.GetFontHeight(), "500");
c.show();
app.exec();
}
{
c.Clear();
c.DrawOutlineRectangle(100, 100, 200, 200, Color(255, 0, 0));
c.show();
app.exec();
}
{
c.Clear();
c.DrawRoundRectangle(100, 100, 200, 200, 10, 10);
c.DrawRoundRectangle(200, 200, 300, 300, 100, 100);
c.DrawRoundRectangle(300, 300, 400, 400, 50, 50);
c.show();
app.exec();
}
{
c.Clear();
PixelRect rc;
rc.left = 100;
rc.top = 100;
rc.right = 200;
rc.bottom = 200;
c.DrawRaisedEdge(rc);
c.show();
app.exec();
}
{
c.Clear();
RasterPoint rp[4];
rp[0] = {100, 100};
rp[1] = {200, 200};
rp[2] = {200, 300};
rp[3] = {300, 400};
c.DrawPolyline(rp, 4);
c.show();
app.exec();
}
{
c.Clear();
RasterPoint rp[6];
rp[0] = {100, 100};
rp[1] = {150, 50};
rp[2] = {200, 100};
rp[3] = {200, 200};
rp[4] = {150, 200};
rp[5] = {100, 100};
c.DrawPolygon(rp, 6);
c.show();
app.exec();
}
{
c.Clear();
RasterPoint rp[4];
rp[0] = {100, 100};
rp[1] = {200, 50};
rp[2] = {200, 150};
rp[3] = {150, 200};
c.DrawTriangleFan(rp, 4);
c.show();
app.exec();
}
{
c.Clear();
c.DrawHLine(100, 200, 100, Color(255, 0, 0));
c.DrawHLine(100, 200, 200, Color(0, 255, 0));
c.DrawHLine(100, 200, 300, Color(0, 0, 255));
c.show();
app.exec();
}
{
c.Clear();
c.DrawLine(100, 100, 200, 200);
c.DrawCircle(250, 250, 50);
c.DrawSegment(100, 250, 50, Angle::Degrees(10), Angle::Degrees(30), false);
c.show();
app.exec();
}
{
c.Clear();
c.DrawAnnulus(100, 100, 50, 100, Angle::Degrees(10), Angle::Degrees(60));
c.DrawAnnulus(300, 100, 50, 100, Angle::Degrees(0), Angle::Degrees(360));
c.DrawAnnulus(100, 300, 50, 100, Angle::Degrees(0), Angle::Degrees(0));
c.show();
app.exec();
}
{
PixelSize rc = c.CalcTextSize("Hello");
std::cout << "Size of \"Hello\": " << rc.cx << ", " << rc.cy << std::endl;
c.DrawClippedText(100, 100, rc.cx / 2, "Hello");
c.show();
app.exec();
}
{
std::cout << "Height of font: " << c.GetFontHeight() << std::endl;
}
{
c.Clear();
c.DrawText(0, 50, "50");
c.Clear();
c.show();
return app.exec();
}
}
void CGWorldOpenGL::DrawGDILineSegments(CDC * dc,CViewMatrix * pViewMatrix, CRect rViewPort,float fLeft, float fRight,float fTop,float fBottom,int iLineSize,BOOL bShowClosureErrors)
{
CPosMatrix fromPos;
CPosMatrix transformedFromPos;
CPosMatrix toPos;
CPosMatrix transformedToPos;
int iCount=m_WireframeLineArray.GetSize();
for (int i=0; i<iCount; i++)
{
const CGWorldOpenGLLine& Line=m_WireframeLineArray.GetAt(i);
fromPos.Set(Line.pt1[0],Line.pt1[1],Line.pt1[2]);
fromPos.Multiply(&transformedFromPos,*pViewMatrix);
toPos.Set(Line.pt2[0],Line.pt2[1],Line.pt2[2]);
toPos.Multiply(&transformedToPos,*pViewMatrix);
//Reverse black and white when printing
COLORREF crColor=Line.crColor;
if (dc->IsPrinting() && crColor==RGB(255,255,255))
{
crColor=RGB(0,0,0);
}
toPos.Normalize();
fromPos.Normalize();
CRect rect;
transformedFromPos.Normalize();
float fFromLeft=((transformedFromPos.GetX()-fLeft)/(fRight-fLeft))*((float)rViewPort.Width())+(float)rViewPort.left;
float fFromTop=(float)rViewPort.bottom-((transformedFromPos.GetY()-fTop)/(fBottom-fTop))*((float)rViewPort.Height());
float fToLeft=((transformedToPos.GetX()-fLeft)/(fRight-fLeft))*((float)rViewPort.Width())+(float)rViewPort.left;
float fToTop=(float)rViewPort.bottom-((transformedToPos.GetY()-fTop)/(fBottom-fTop))*((float)rViewPort.Height());
CPen Pen(PS_SOLID,iLineSize,crColor);
CPen * pPenOld=dc->SelectObject(&Pen);
dc->MoveTo((int)fFromLeft,(int)fFromTop);
dc->LineTo((int)fToLeft,(int)fToTop);
dc->SelectObject(pPenOld);
}
iCount=m_LineArray.GetSize();
for (i=0; i<iCount; i++)
{
const CGWorldOpenGLLine& Line=m_LineArray.GetAt(i);
//crColor==CLOSURE_RGB indicates loop closure.
BOOL bShowThisLine=TRUE;
if (Line.crColor==CLOSURE_RGB)
{
bShowThisLine=bShowClosureErrors;
}
if (bShowThisLine)
{
fromPos.Set(Line.pt1[0],Line.pt1[1],Line.pt1[2]);
fromPos.Multiply(&transformedFromPos,*pViewMatrix);
toPos.Set(Line.pt2[0],Line.pt2[1],Line.pt2[2]);
toPos.Multiply(&transformedToPos,*pViewMatrix);
//Reverse black and white when printing
COLORREF crColor=Line.crColor;
if (dc->IsPrinting() && crColor==RGB(255,255,255))
{
crColor=RGB(0,0,0);
}
toPos.Normalize();
fromPos.Normalize();
CRect rect;
transformedFromPos.Normalize();
float fFromLeft=((transformedFromPos.GetX()-fLeft)/(fRight-fLeft))*((float)rViewPort.Width())+(float)rViewPort.left;
float fFromTop=(float)rViewPort.bottom-((transformedFromPos.GetY()-fTop)/(fBottom-fTop))*((float)rViewPort.Height());
float fToLeft=((transformedToPos.GetX()-fLeft)/(fRight-fLeft))*((float)rViewPort.Width())+(float)rViewPort.left;
float fToTop=(float)rViewPort.bottom-((transformedToPos.GetY()-fTop)/(fBottom-fTop))*((float)rViewPort.Height());
CPen Pen(crColor==CLOSURE_RGB?PS_DASH:PS_SOLID,iLineSize,crColor==CLOSURE_RGB?RGB(255,0,0):crColor);
CPen * pPenOld=dc->SelectObject(&Pen);
dc->MoveTo((int)fFromLeft,(int)fFromTop);
dc->LineTo((int)fToLeft,(int)fToTop);
dc->SelectObject(pPenOld);
}
}
int iTriangleGroupCount=m_TriangleGroupArray.GetSize();
for (i=0; i<iTriangleGroupCount; i++)
{
CGWorldTriangleGroup const * pGroup=m_TriangleGroupArray.GetAt(i);
pGroup->DumpToGL();
}
glEndList();
}
void CPenBrushUnit::DrawMultiPenBrush(CDC *memDC,CPoint ePoint,std::vector<temSavePoint> &MultipsPoint,MultiInfo &GetMultiInfo,DWORD mouseid)
{
int Red,Green,Blue;
Red=GetRValue(GetMultiInfo.penColor);
Green=GetGValue(GetMultiInfo.penColor);
Blue=GetBValue(GetMultiInfo.penColor);
Graphics mGraphics(memDC->m_hDC);
mGraphics.SetSmoothingMode(SmoothingModeAntiAlias);
SolidBrush brush(Color(255,Red,Green,Blue));
UINT Size=MultipsPoint.size();
CPoint sPoint=MultipsPoint[Size-1].point;
if(Size==1)
{
if(fwidth.find(mouseid)!=fwidth.end())
fwidth.erase(mouseid);
fwidth.insert(std::map<DWORD,float>::value_type(mouseid,MultipsPoint[0].preWidth));
PushStart(ePoint,mouseid);
}
if(Push(sPoint,ePoint,mouseid))
{
RectF headRect;
RectF tailRect;
float width,dx,dy;
PointF lfCenter,rtCenter;
mGraphics.FillPolygon(&brush,pts,npts);
mGraphics.DrawPolygon(&Pen(Color(255,Red,Green,Blue),0.5f),pts,npts);
if(npts==4)
{
headRect=RectF((pts[0].X+pts[3].X)/2.0f,(pts[0].Y+pts[3].Y)/2.0f,0.0f,0.0f);
tailRect=RectF((pts[1].X+pts[2].X)/2.0f,(pts[1].Y+pts[2].Y)/2.0f,0.0f,0.0f);
dx=pts[3].X-pts[0].X;
dy=pts[3].Y-pts[0].Y;
width=sqrt(dx*dx+dy*dy)/2.0f+0.5f;
headRect.Inflate(width,width);
dx=pts[2].X-pts[1].X;
dy=pts[2].Y-pts[1].Y;
width=sqrt(dx*dx+dy*dy)/2.0f+0.5f;
tailRect.Inflate(width,width);
}
else
{
headRect=RectF((pts[0].X+pts[9].X)/2.0f,(pts[0].Y+pts[9].Y)/2.0f,0.0f,0.0f);
tailRect=RectF((pts[4].X+pts[5].X)/2.0f,(pts[4].Y+pts[5].Y)/2.0f,0.0f,0.0f);
dx=pts[9].X-pts[0].X;
dy=pts[9].Y-pts[0].Y;
width=sqrt(dx*dx+dy*dy)/2.0f+0.5f;
headRect.Inflate(width,width);
dx=pts[5].X-pts[4].X;
dy=pts[5].Y-pts[4].Y;
width=sqrt(dx*dx+dy*dy)/2.0f+0.5f;
tailRect.Inflate(width,width);
}
brush.SetColor(Color(255,Red,Green,Blue));
mGraphics.FillEllipse(&brush,headRect);
mGraphics.FillEllipse(&brush,tailRect);
temSavePoint addPoint;
addPoint.point=ePoint;
addPoint.alpha=MultipsPoint[Size-1].alpha;
addPoint.preWidth=MultipsPoint[Size-1].preWidth;
MultipsPoint.push_back(addPoint);
}
}
void TetrahedronDlg::TetrahedronDlgPaint(wxPaintEvent& WXUNUSED(event))
{
SetBackgroundStyle(wxBG_STYLE_CUSTOM);
wxBufferedPaintDC dc(this);
// Get window dimensions
wxSize sz = GetClientSize();
// determine the center of the canvas
const wxPoint center(wxPoint(sz.x / 2, sz.y / 2));
// create background color
wxColour powderblue = wxColour(176,224,230);
// draw powderblue background
dc.SetPen(powderblue);
dc.SetBrush(powderblue);
dc.DrawRectangle(0, 0, sz.x, sz.y);
// draw clock border
wxPen Pen(*wxBLACK_PEN);
Pen.SetWidth(1);
dc.SetPen(Pen);
dc.SetBrush(*wxBLACK_BRUSH);
// initial cube coordinates:
// --> use center.x (center.y) to ensure the tetrahedron stays allways in the center of the canvas
dc.DrawLine((int)(m_p[0][X])+center.x,(int)(m_p[0][Y])+center.y,(int)(m_p[1][X])+center.x,(int)(m_p[1][Y])+center.y);
dc.DrawLine((int)(m_p[1][X])+center.x,(int)(m_p[1][Y])+center.y,(int)(m_p[2][X])+center.x,(int)(m_p[2][Y])+center.y);
dc.DrawLine((int)(m_p[2][X])+center.x,(int)(m_p[2][Y])+center.y,(int)(m_p[0][X])+center.x,(int)(m_p[0][Y])+center.y);
dc.DrawLine((int)(m_p[0][X])+center.x,(int)(m_p[0][Y])+center.y,(int)(m_p[3][X])+center.x,(int)(m_p[3][Y])+center.y);
dc.DrawLine((int)(m_p[1][X])+center.x,(int)(m_p[1][Y])+center.y,(int)(m_p[3][X])+center.x,(int)(m_p[3][Y])+center.y);
dc.DrawLine((int)(m_p[2][X])+center.x,(int)(m_p[2][Y])+center.y,(int)(m_p[3][X])+center.x,(int)(m_p[3][Y])+center.y);
// Kreuzprodukt der eine Flaeche aufspannenden Vektoren bilden
// Wenn Betrag der z-Koordinate positiv: Flaeche anzeigen
if(((m_p[0][X]-m_p[1][X])*(m_p[2][Y]-m_p[1][Y])-(m_p[0][Y]-m_p[1][Y])*(m_p[2][X]-m_p[1][X])) > 0)
{
wxPoint pt[3];
pt[0].x = (m_p[0][X])+center.x;
pt[1].x = (m_p[1][X])+center.x;
pt[2].x = (m_p[2][X])+center.x;
pt[0].y = (m_p[0][Y])+center.y;
pt[1].y = (m_p[1][Y])+center.y;
pt[2].y = (m_p[2][Y])+center.y;
dc.SetBrush(*wxRED_BRUSH);
dc.DrawPolygon(3,pt);
}
if(((m_p[2][X]-m_p[1][X])*(m_p[3][Y]-m_p[1][Y])-(m_p[2][Y]-m_p[1][Y])*(m_p[3][X]-m_p[1][X])) > 0)
{
wxPoint pt[3];
pt[0].x = (m_p[2][X])+center.x;
pt[1].x = (m_p[1][X])+center.x;
pt[2].x = (m_p[3][X])+center.x;
pt[0].y = (m_p[2][Y])+center.y;
pt[1].y = (m_p[1][Y])+center.y;
pt[2].y = (m_p[3][Y])+center.y;
dc.SetBrush(*wxGREEN_BRUSH);
dc.DrawPolygon(3,pt);
}
if(((m_p[3][X]-m_p[1][X])*(m_p[0][Y]-m_p[1][Y])-(m_p[3][Y]-m_p[1][Y])*(m_p[0][X]-m_p[1][X])) > 0)
{
wxPoint pt[3];
pt[0].x = (m_p[3][X])+center.x;
pt[1].x = (m_p[1][X])+center.x;
pt[2].x = (m_p[0][X])+center.x;
pt[0].y = (m_p[3][Y])+center.y;
pt[1].y = (m_p[1][Y])+center.y;
pt[2].y = (m_p[0][Y])+center.y;
dc.SetBrush(*wxBLUE_BRUSH);
dc.DrawPolygon(3,pt);
}
if(((m_p[2][X]-m_p[3][X])*(m_p[0][Y]-m_p[3][Y])-(m_p[2][Y]-m_p[3][Y])*(m_p[0][X]-m_p[3][X])) > 0)
{
wxPoint pt[3];
pt[0].x = (m_p[2][X])+center.x;
pt[1].x = (m_p[3][X])+center.x;
pt[2].x = (m_p[0][X])+center.x;
pt[0].y = (m_p[2][Y])+center.y;
pt[1].y = (m_p[3][Y])+center.y;
pt[2].y = (m_p[0][Y])+center.y;
dc.SetBrush(*wxGREY_BRUSH);
dc.DrawPolygon(3,pt);
}
}
void black_pen() {
pen = Pen(1, COLOR_BLACK);
}
// Set the pen color, using an enum value (e.g. ScrollView::ORANGE)
void ScrollView::Pen(Color color) {
Pen(table_colors[color][0], table_colors[color][1],
table_colors[color][2], table_colors[color][3]);
}
void SelectNullPen() {
pen = Pen(0, COLOR_BLACK);
}
void CPenBrushUnit::ReDraw(CDC* memDC,DataInfo &pDataInfo)
{
CPoint sPoint,ePoint,psPoint,pePoint,ptPoint;
double dx,dy,xlen,ylen;
double preWidth,nWidth;
Matrix matrix;
int count=1;
int alpha;
int v=0;
int Red,Green,Blue;
Red=GetRValue(pDataInfo.penColor);
Green=GetGValue(pDataInfo.penColor);
Blue=GetBValue(pDataInfo.penColor);
SolidBrush brush(Color(255,Red,Green,Blue));
SolidBrush brush1(Color(200,Red,Green,Blue));
Graphics mGraphics(memDC->m_hDC);
mGraphics.TranslateTransform(pDataInfo.CenterPoint.x,pDataInfo.CenterPoint.y);
mGraphics.RotateTransform(pDataInfo.RotateAngle);
mGraphics.SetSmoothingMode(SmoothingModeAntiAlias);
mGraphics.ScaleTransform(pDataInfo.xScale,pDataInfo.yScale);
///////////////////////////////////
Region tRgn;
Region *ptRgn=tRgn.FromHRGN(pDataInfo.hRgn);
if(ptRgn != NULL)
mGraphics.ExcludeClip(ptRgn);
delete ptRgn;
////////////////////////////////////
int Size=pDataInfo.AllRate.size();
sPoint=CaculatePoint(pDataInfo.StartPoint,pDataInfo);
ePoint=CaculatePoint(pDataInfo.EndPoint,pDataInfo);
xlen=ePoint.x-sPoint.x;
ylen=ePoint.y-sPoint.y;
if(xlen<1)
xlen=1;
if(ylen<1)
ylen=1;
if(fwidth.size()!=0)
fwidth.clear();
fwidth.insert(std::map<DWORD,float>::value_type(0,pDataInfo.AllRate[0].preWidth));
alpha=pDataInfo.AllRate[0].alpha;
psPoint.x=sPoint.x+xlen*pDataInfo.AllRate[0].xRate;
psPoint.y=sPoint.y+ylen*pDataInfo.AllRate[0].yRate;
for(int Index=1;Index<Size;Index++)
{
pePoint.x=sPoint.x+xlen*pDataInfo.AllRate[Index].xRate;
pePoint.y=sPoint.y+ylen*pDataInfo.AllRate[Index].yRate;
if(Index==1)
PushStart(psPoint,0);
if(Push(psPoint,pePoint,0))
{
RectF headRect;
RectF tailRect;
float width,dx,dy;
PointF lfCenter,rtCenter;
mGraphics.FillPolygon(&brush,pts,npts);
mGraphics.DrawPolygon(&Pen(Color(200,Red,Green,Blue),1),pts,npts);
if(npts==4)
{
headRect=RectF((pts[0].X+pts[3].X)/2.0f,(pts[0].Y+pts[3].Y)/2.0f,0.0f,0.0f);
tailRect=RectF((pts[1].X+pts[2].X)/2.0f,(pts[1].Y+pts[2].Y)/2.0f,0.0f,0.0f);
dx=pts[3].X-pts[0].X;
dy=pts[3].Y-pts[0].Y;
width=sqrt(dx*dx+dy*dy)/2.0f+0.5f;
headRect.Inflate(width,width);
dx=pts[2].X-pts[1].X;
dy=pts[2].Y-pts[1].Y;
width=sqrt(dx*dx+dy*dy)/2.0f+0.5f;
tailRect.Inflate(width,width);
}
else
{
headRect=RectF((pts[0].X+pts[9].X)/2.0f,(pts[0].Y+pts[9].Y)/2.0f,0.0f,0.0f);
tailRect=RectF((pts[4].X+pts[5].X)/2.0f,(pts[4].Y+pts[5].Y)/2.0f,0.0f,0.0f);
dx=pts[9].X-pts[0].X;
dy=pts[9].Y-pts[0].Y;
width=sqrt(dx*dx+dy*dy)/2.0f+0.5f;
headRect.Inflate(width,width);
dx=pts[5].X-pts[4].X;
dy=pts[5].Y-pts[4].Y;
width=sqrt(dx*dx+dy*dy)/2.0f+0.5f;
tailRect.Inflate(width,width);
}
mGraphics.FillEllipse(&brush1,headRect);
mGraphics.FillEllipse(&brush1,tailRect);
//preWidth=nWidth;
psPoint=pePoint;
}
}
mGraphics.ResetTransform();
}
void SelectBlackPen() {
pen = Pen(1, COLOR_BLACK);
}
void white_pen() {
pen = Pen(1, COLOR_WHITE);
}
