Exemplo n.º 1
0
inline Polylines to_polylines(ExPolygon &&src)
{
    Polylines polylines;
    polylines.assign(src.holes.size() + 1, Polyline());
    size_t idx = 0;
    Polyline &pl = polylines[idx ++];
    pl.points = std::move(src.contour.points);
    pl.points.push_back(pl.points.front());
    for (Polygons::const_iterator ith = src.holes.begin(); ith != src.holes.end(); ++ith) {
        Polyline &pl = polylines[idx ++];
        pl.points = std::move(ith->points);
        pl.points.push_back(ith->points.front());
    }
    assert(idx == polylines.size());
    return polylines;
}
Exemplo n.º 2
0
Polylines _clipper_pl(ClipperLib::ClipType clipType, const Polygons &subject, const Polygons &clip, bool safety_offset_)
{
    // transform input polygons into polylines
    Polylines polylines;
    polylines.reserve(subject.size());
    for (Polygons::const_iterator polygon = subject.begin(); polygon != subject.end(); ++polygon)
        polylines.emplace_back(polygon->operator Polyline());  // implicit call to split_at_first_point()
    
    // perform clipping
    Polylines retval = _clipper_pl(clipType, polylines, clip, safety_offset_);
    
    /* If the split_at_first_point() call above happens to split the polygon inside the clipping area
       we would get two consecutive polylines instead of a single one, so we go through them in order
       to recombine continuous polylines. */
    for (size_t i = 0; i < retval.size(); ++i) {
        for (size_t j = i+1; j < retval.size(); ++j) {
            if (retval[i].points.back() == retval[j].points.front()) {
                /* If last point of i coincides with first point of j,
                   append points of j to i and delete j */
                retval[i].points.insert(retval[i].points.end(), retval[j].points.begin()+1, retval[j].points.end());
                retval.erase(retval.begin() + j);
                --j;
            } else if (retval[i].points.front() == retval[j].points.back()) {
                /* If first point of i coincides with last point of j,
                   prepend points of j to i and delete j */
                retval[i].points.insert(retval[i].points.begin(), retval[j].points.begin(), retval[j].points.end()-1);
                retval.erase(retval.begin() + j);
                --j;
            } else if (retval[i].points.front() == retval[j].points.front()) {
                /* Since Clipper does not preserve orientation of polylines, 
                   also check the case when first point of i coincides with first point of j. */
                retval[j].reverse();
                retval[i].points.insert(retval[i].points.begin(), retval[j].points.begin(), retval[j].points.end()-1);
                retval.erase(retval.begin() + j);
                --j;
            } else if (retval[i].points.back() == retval[j].points.back()) {
                /* Since Clipper does not preserve orientation of polylines, 
                   also check the case when last point of i coincides with last point of j. */
                retval[j].reverse();
                retval[i].points.insert(retval[i].points.end(), retval[j].points.begin()+1, retval[j].points.end());
                retval.erase(retval.begin() + j);
                --j;
            }
        }
    }
    return retval;
}
Exemplo n.º 3
0
/*
 * VENTA3 This is a modified Segment()
 */
int LKSurface::DrawArc(long x, long y, int radius, const RECT& rc, double start, double end) {
    POINT pt[66];
    int i;
    int istart;
    int iend;

    if ((x - radius) > rc.right) return false;
    if ((x + radius) < rc.left) return false;
    if ((y - radius) > rc.bottom) return false;
    if ((y + radius) < rc.top) return false;

    // JMW added faster checking...

    start = AngleLimit360(start);
    end = AngleLimit360(end);

    istart = iround(start / 360.0 * 64);
    iend = iround(end / 360.0 * 64);

    int npoly = 0;

    if (istart > iend) {
        iend += 64;
    }
    istart++;
    iend--;

    pt[npoly].x = x + (long) (radius * fastsine(start));
    pt[npoly].y = y - (long) (radius * fastcosine(start));
    npoly++;

    for (i = 0; i < 64; i++) {
        if (i <= iend - istart) {
            pt[npoly].x = x + (long) (radius * xcoords[(i + istart) % 64]);
            pt[npoly].y = y - (long) (radius * ycoords[(i + istart) % 64]);
            npoly++;
        }
    }
    pt[npoly].x = x + (long) (radius * fastsine(end));
    pt[npoly].y = y - (long) (radius * fastcosine(end));
    npoly++;

    Polyline(pt, npoly, rc);

    return true;
}
Exemplo n.º 4
0
void
Poly(HDC hdc, POINT * lpPoints, int nCount,  COLORREF fg,  COLORREF bg, int thickness, int style, BOOL closed)
{
    LOGBRUSH logbrush;
    HBRUSH oldBrush;
    HPEN oldPen = SelectObject(hdc, CreatePen(PS_SOLID, thickness, fg));
    logbrush.lbStyle = (style == 0) ? BS_HOLLOW : BS_SOLID;
    logbrush.lbColor = (style == 2) ? fg : bg;
    logbrush.lbHatch = 0;
    oldBrush = SelectObject(hdc, CreateBrushIndirect(&logbrush));
    if (closed)
        Polygon(hdc, lpPoints, nCount);
    else
        Polyline(hdc, lpPoints, nCount);
    DeleteObject(SelectObject(hdc, oldBrush));
    DeleteObject(SelectObject(hdc, oldPen));
}
Exemplo n.º 5
0
void CSkeletalViewerApp::Nui_DrawSkeletonSegment( NUI_SKELETON_DATA * pSkel, int numJoints, ... )
{
    va_list vl;
    va_start(vl,numJoints);
    POINT segmentPositions[NUI_SKELETON_POSITION_COUNT];

    for (int iJoint = 0; iJoint < numJoints; iJoint++)
    {
        NUI_SKELETON_POSITION_INDEX jointIndex = va_arg(vl,NUI_SKELETON_POSITION_INDEX);
        segmentPositions[iJoint].x = m_Points[jointIndex].x;
        segmentPositions[iJoint].y = m_Points[jointIndex].y;
    }

    Polyline(m_SkeletonDC, segmentPositions, numJoints);

    va_end(vl);
}
Exemplo n.º 6
0
void LKSurface::DrawCircle(long x, long y, int radius, const RECT& rc, bool fill) {

    if ((x - radius) > rc.right) return;
    if ((x + radius) < rc.left) return;
    if ((y - radius) > rc.bottom) return;
    if ((y + radius) < rc.top) return;

    // Only called by ThreadDraw, so static vector can be used.
    static std::vector<RasterPoint> CirclePt;
    buildCircle(RasterPoint(x,y), radius, CirclePt);
      
    if (fill) {
        Polygon(CirclePt.data(), CirclePt.size(), rc);
    } else {
        Polyline(CirclePt.data(), CirclePt.size(), rc);
    }
}
Exemplo n.º 7
0
static void
l_ui_polyline(struct rdp_inst * inst, uint8 opcode, RD_POINT * points, int npoints,
	RD_PEN * pen)
{
	wfInfo * wfi;
	HPEN hpen;
	HPEN org_hpen;
	int color;
	int org_rop2;
	int i;
	POINT * ps;

	wfi = GET_WFI(inst);
	//printf("ui_polyline opcode %d npoints %d\n", opcode, npoints);
	color = wf_color_convert(wfi, pen->color, inst->settings->server_depth);
	hpen = CreatePen(pen->style, pen->width, color);
	org_rop2 = SetROP2(wfi->drw->hdc, opcode + 1);
	org_hpen = (HPEN)SelectObject(wfi->drw->hdc, hpen);
	if (npoints > 0)
	{
		ps = (POINT *) malloc(sizeof(POINT) * npoints);
		for (i = 0; i < npoints; i++)
		{
			//printf("ui_polyline point %d %d %d\n", i, points[i].x, points[i].y);
			if (i == 0)
			{
				ps[i].x = points[i].x;
				ps[i].y = points[i].y;
			}
			else
			{
				ps[i].x = ps[i - 1].x + points[i].x;
				ps[i].y = ps[i - 1].y + points[i].y;
			}
			if (wfi->drw == wfi->backstore)
			{
				wf_invalidate_region(wfi, ps[i].x, ps[i].y, ps[i].x + 1, ps[i].y + 1);
			}
		}
		Polyline(wfi->drw->hdc, ps, npoints);
	}
	SelectObject(wfi->drw->hdc, org_hpen);
	SetROP2 (wfi->drw->hdc, org_rop2);
	DeleteObject(hpen);
}
Exemplo n.º 8
0
inline Polylines to_polylines(const ExPolygons &src)
{
    Polylines polylines;
    polylines.assign(number_polygons(src), Polyline());
    size_t idx = 0;
    for (ExPolygons::const_iterator it = src.begin(); it != src.end(); ++it) {
        Polyline &pl = polylines[idx ++];
        pl.points = it->contour.points;
        pl.points.push_back(pl.points.front());
        for (Polygons::const_iterator ith = it->holes.begin(); ith != it->holes.end(); ++ith) {
            Polyline &pl = polylines[idx ++];
            pl.points = ith->points;
            pl.points.push_back(ith->points.front());
        }
    }
    assert(idx == polylines.size());
    return polylines;
}
Exemplo n.º 9
0
bool GiCanvasGdi::rawLines(const GiContext* ctx, 
                           const Point2d* pxs, int count)
{
    HDC hdc = m_draw->getDrawDC();
    KGDIObject pen (hdc, m_draw->createPen(ctx), false);
    bool ret = false;

    if (count > 0)
    {
        std::vector<POINT> pts;
        pts.resize(count);
        for (int i = 0; i < count; i++)
            pxs[i].get(pts[i].x, pts[i].y);
        ret = !!Polyline(hdc, &pts.front(), count);
    }

    return ret;
}
Exemplo n.º 10
0
LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)//视窗讯息处理程式
{
	//CS_视窗类别样式
	//CW_建立视窗
	//DT_绘制文字
	//IDI_图示ID
	//IDC_游标ID
	//MB_讯息方块
	//SND_声音
	//WM_视窗讯息
	//WS_视窗样式
	HDC hdc;
	PAINTSTRUCT ps;
	//	RECT rect;

	static int cxClient,cyClient;
	int i;
	POINT apt[NUM];
	switch (message)
	{
	case WM_SIZE:
		cxClient = LOWORD(lParam);
		cyClient = HIWORD(lParam);
		return 0;
	case WM_PAINT:
		hdc = BeginPaint(hwnd, &ps);
		MoveToEx(hdc, 0, cyClient / 2, NULL);
		LineTo(hdc, cxClient, cyClient / 2);
		for (i = 0; i < NUM; i++)
		{
			apt[i].x = i*cxClient / NUM;
			apt[i].y = (int)(cyClient / 2 * (1 - sin(TWOPI*i / NUM)));
		}
		Polyline(hdc, apt,sizeof(apt)/sizeof(POINT));
	//	Polyline(hdc, apt, NUM);与上面相等
	//	EndPaint(hwnd, &ps);
		return 0;
	case WM_DESTROY:
		PostQuitMessage(0);
		return 0;
	}
	//视窗讯息处理程式不予处理的所有讯息提供内定处理
	return DefWindowProc(hwnd, message, wParam, lParam);
}
Exemplo n.º 11
0
void DrawHands(HDC hdc, SYSTEMTIME* pst, BOOL fChange)
{
	static POINT pt[3][5] = {
		0, -150, 100, 0, 0, 600, -100, 0, 0, -150,
		0, -200, 50, 0, 0, 800, -50, 0, 0, -200,
		0, 0, 0, 0, 0, 0, 0, 0, 0, 800
	};
	int i, iAngle[3];
	POINT ptTemp[3][5];
	iAngle[0] = (pst->wHour * 30) % 360 + pst->wMinute / 2;
	iAngle[1] = pst->wMinute * 6;
	iAngle[2] = pst->wSecond * 6;
	memcpy(ptTemp, pt, sizeof(pt));
	for (i = fChange ? 0 : 2; i < 3;i++)
	{
		RotatePoint(ptTemp[i], 5, iAngle[i]);
		Polyline(hdc, ptTemp[i], 5);
	}
}
Exemplo n.º 12
0
Lines
_clipper_ln(ClipperLib::ClipType clipType, const Lines &subject, const Polygons &clip,
    bool safety_offset_)
{
    // convert Lines to Polylines
    Polylines polylines;
    polylines.reserve(subject.size());
    for (const Line &line : subject)
        polylines.emplace_back(Polyline(line.a, line.b));
    
    // perform operation
    polylines = _clipper_pl(clipType, polylines, clip, safety_offset_);
    
    // convert Polylines to Lines
    Lines retval;
    for (Polylines::const_iterator polyline = polylines.begin(); polyline != polylines.end(); ++polyline)
        retval.emplace_back(polyline->operator Line());
    return retval;
}
Exemplo n.º 13
0
void wf_gdi_polyline(wfContext* wfc, POLYLINE_ORDER* polyline)
{
	int i;
	POINT* pts;
	int org_rop2;
	HPEN hpen;
	HPEN org_hpen;
	UINT32 pen_color;

	pen_color = freerdp_color_convert_var_bgr(polyline->penColor, wfc->srcBpp, wfc->dstBpp, wfc->clrconv);

	hpen = CreatePen(0, 1, pen_color);
	org_rop2 = wf_set_rop2(wfc->drawing->hdc, polyline->bRop2);
	org_hpen = (HPEN) SelectObject(wfc->drawing->hdc, hpen);

	if (polyline->numPoints > 0)
	{
		POINT temp;

		temp.x = polyline->xStart;
		temp.y = polyline->yStart;
		pts = (POINT*) malloc(sizeof(POINT) * polyline->numPoints);

		for (i = 0; i < (int) polyline->numPoints; i++)
		{
			temp.x += polyline->points[i].x;
			temp.y += polyline->points[i].y;
			pts[i].x = temp.x;
			pts[i].y = temp.y;

			if (wfc->drawing == wfc->primary)
				wf_invalidate_region(wfc, pts[i].x, pts[i].y, pts[i].x + 1, pts[i].y + 1);
		}

		Polyline(wfc->drawing->hdc, pts, polyline->numPoints);
		free(pts);
	}

	SelectObject(wfc->drawing->hdc, org_hpen);
	wf_set_rop2(wfc->drawing->hdc, org_rop2);
	DeleteObject(hpen);
}
Exemplo n.º 14
0
void drawRectangle(int x, int y, int width, int height)
{
	POINT point[5];
	point[0].x = x;
	point[0].y = y;

	point[1].x = x + width;
	point[1].y = y;

	point[2].x = x + width;
	point[2].y = y + height;

	point[3].x = x;
	point[3].y = y + height;

	point[4].x = x;
	point[4].y = y;

	Polyline(_paintDC, point, 5);
}
void PaintSinWave(HWND hwnd, int cxClient, int cyClient)
{
	int         i ;
	PAINTSTRUCT ps ;
	POINT       apt [NUM] ;
	HDC hdc = BeginPaint (hwnd, &ps) ;

	MoveToEx (hdc, 0,        cyClient / 2, NULL) ;
	LineTo   (hdc, cxClient, cyClient / 2) ;

	for (i = 0 ; i < NUM ; i++)
	{
		apt[i].x = i * cxClient / NUM ;
		apt[i].y = (int) (cyClient / 2 * (1 - sin (TWOPI * i / NUM))) ;
	}

	Polyline (hdc, apt, NUM) ;

	EndPaint (hwnd, &ps) ;
}
Exemplo n.º 16
0
// Draw OfficeManagerASE
void OfficeGSE::DrawOfficeManagerASE(HINSTANCE hinst, HWND hwnd, HDC hdc, ActorRequest* ActReq)
{
	int r = ActReq->GetRequest();
	int c = ActReq->GetActorId();
	int bottom = ActReq->GetIntParam1();
	int top = ActReq->GetIntParam2();
	int right = ActReq->GetIntParam3();
	int left = ActReq->GetIntParam4();

	SetBkMode(hdc, TRANSPARENT);
	HPEN Pen = CreatePen(PS_DOT, 0, RGB(255, 255, 255));
	SelectObject(hdc, Pen);
	POINT p[5];
	p[0].x = left;  p[0].y = top;
	p[1].x = right; p[1].y = top;
	p[2].x = right; p[2].y = bottom;
	p[3].x = left;  p[3].y = bottom;
	p[4].x = left;  p[4].y = top;
	Polyline(hdc, p, 5);
	DeleteObject(Pen);
}
Exemplo n.º 17
0
// ****************************************************************************
//
//  Function Name:	RGpDrawingSurface::SolidFillPolygon( )
//
//  Description:		Fills a solid polygon
//
//  Returns:			Nothing
//
//  Exceptions:		None
//
// ****************************************************************************
//
void RGpDrawingSurface::SolidFillPolygon( const RIntPoint* pPoints, YPointCount numPoints )
{
    PolyHandle		hPoly;

    TpsAssert( ( numPoints < kMaxPoints ), "Too many points." );

    if ( numPoints == 2 )
    {
        Polyline( pPoints, numPoints );										// REVEIW RAH should use fill color
    }
    else
    {
        hPoly = CreatePolygon( pPoints, numPoints );

        CreateBrush( );

        ::FillPoly( hPoly, &qd.black );

        ::DisposeHandle( (Handle)hPoly );
    }
}
Exemplo n.º 18
0
int GPpolygon (Gwidget_t *widget, int gpn, Gpoint_t *gpp, Ggattr_t *ap) {
    int n, i;

    if (gpn == 0)
        return 0;
    if (gpn + 1 > Gppn) {
        n = (((gpn + 1) + PPINCR - 1) / PPINCR) * PPINCR;
        Gppp = Marraygrow (Gppp, (long) n * PPSIZE);
        Gppn = n;
    }
    for (i = 0; i < gpn; i++)
        Gppp[i] = pdrawtopix (widget, gpp[i]);
    setgattr (widget, ap);
    if (WPU->gattr.fill) {
        if (Gppp[gpn - 1].x != Gppp[0].x || Gppp[gpn - 1].y != Gppp[0].y)
            Gppp[gpn] = Gppp[0], gpn++;
        Polygon (GC, Gppp, (int) gpn);
    } else
        Polyline (GC, Gppp, (int) gpn);
    return 0;
}
Exemplo n.º 19
0
void Statistics::StyleLine(HDC hdc, POINT l1, POINT l2,
                           int Style) {
  POINT line[2];
  line[0] = l1;
  line[1] = l2;
  switch (Style) {
  case STYLE_BLUETHIN:
    DrawDashLine(hdc, 1, 
                 l1, 
                 l2, 
                 RGB(0,0,255));
    break;
  case STYLE_REDTHICK:
    DrawDashLine(hdc, 3, 
                 l1, 
                 l2, 
                 RGB(200,50,50));
    break;
  case STYLE_DASHGREEN:
    DrawDashLine(hdc, 2, 
                 line[0], 
                 line[1], 
                 RGB(0,255,0));
    break;
  case STYLE_MEDIUMBLACK:
    SelectObject(hdc, GetStockObject(BLACK_PEN));
    Polyline(hdc, line, 2);
    break;
  case STYLE_THINDASHPAPER:
    DrawDashLine(hdc, 1, 
                 l1, 
                 l2, 
                 RGB(0xf0,0xf0,0xb0));    
    break;

  default:
    break;
  }

}
Exemplo n.º 20
0
void iupDrawPolygon(IdrawCanvas* dc, int* points, int count, unsigned char r, unsigned char g, unsigned char b, int style)
{
  if (style==IUP_DRAW_FILL)
  {
    HBRUSH hBrush = CreateSolidBrush(RGB(r,g,b));
    HPEN hBrushOld = SelectObject(dc->hBitmapDC, hBrush); 
    BeginPath(dc->hBitmapDC); 
    Polygon(dc->hBitmapDC, (POINT*)points, count);
    EndPath(dc->hBitmapDC);
    FillPath(dc->hBitmapDC);
    SelectObject(dc->hBitmapDC, hBrushOld);
    DeleteObject(hBrush);
  }
  else
  {
    HPEN hPen = CreatePen(style==IUP_DRAW_STROKE_DASH? PS_DASH: PS_SOLID, 1, RGB(r, g, b));
    HPEN hPenOld = SelectObject(dc->hBitmapDC, hPen);
    Polyline(dc->hBitmapDC, (POINT*)points, count);
    SelectObject(dc->hBitmapDC, hPenOld);
    DeleteObject(hPen);
  }
}
Exemplo n.º 21
0
LRESULT CALLBACK WndProc (HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam)
     {
     static int  cxClient, cyClient ;
     HDC         hdc ;
     int         i ;
     PAINTSTRUCT ps ;
     POINT       pt [NUM] ;

     switch (iMsg)
          {
          case WM_SIZE:
               cxClient = LOWORD (lParam) ;
               cyClient = HIWORD (lParam) ;
               return 0 ;

          case WM_PAINT:
               hdc = BeginPaint (hwnd, &ps) ;

               MoveToEx (hdc, 0,        cyClient / 2, NULL) ;
               LineTo   (hdc, cxClient, cyClient / 2) ;

               for (i = 0 ; i < NUM ; i++)
                    {
                    pt[i].x = i * cxClient / NUM ;
                    pt[i].y = (int) (cyClient / 2 *
                                    (1 - sin (TWOPI * i / NUM))) ;
                    }

               Polyline (hdc, pt, NUM) ;

               return 0 ;

          case WM_DESTROY:
               PostQuitMessage (0) ;
               return 0 ;
          }

     return DefWindowProc (hwnd, iMsg, wParam, lParam) ;
     }
Exemplo n.º 22
0
static void calculate_polyline(void)
{
    WINT points, i;
    RECT rect;
    POINT p[9];
    HPEN hOldPen;
    do {
        rect.left = 0x7fff;
        rect.top = 0x7fff;
        rect.right = 0;
        rect.bottom = 0;
        points = get_rand(2, 9);
        for (i=0; i<points; i++)
        {
            p[i].x = get_rand(0, xMax);
            p[i].y = get_rand(0, yMax);
            if (p[i].x < rect.left)
                rect.left = p[i].x;
            if (p[i].x > rect.right)
                rect.right = p[i].x;
            if (p[i].y < rect.top)
                rect.top = p[i].y;
            if (p[i].y > rect.bottom)
                rect.bottom = p[i].y;
        }
        hOldPen = SelectObject(hMemDC, create_pen());
        SetROP2(hMemDC, get_rand(1,17));
        Polyline(hMemDC, &p[0], points);
        DeleteObject(SelectObject(hMemDC, hOldPen));
        if (TestSemaphore(&PainterRequired) < 0)
        {
            InvalidateRect(hWnd, &rect, FALSE);
            UpdateWindow(hWnd);
        }
    } while ((TestSemaphore(&DemoRun)) && (!TestSemaphore(&SingleRun)));
    
    if (!TestSemaphore(&SingleRun));
        Signal(&Done);
}
Exemplo n.º 23
0
Arquivo: clb.c Projeto: mingpen/OpenNT
BOOL
DrawLine(
    IN HDC hDC,
    IN LPDRAW_ERASE_LINE DrawEraseLine
    )

/*++

Routine Description:

    DrawLine draws the Draw line in the supplied DrawEraseLine structure
    and then sets up that line so that EraseLine will erase it.

Arguments:

    hDC             - Supplies a handle to the DC where the line should be
                      drawn.
    DrawEraseLine   - Supplies a pointer to a DRAW_ERASE_LINE structure that
                      conatins the coordinates for the line to be drawn.

Return Value:

    BOOL - Returns TRUE if the line was succesfully drawn.

--*/

{
    BOOL    Success;

    DbgHandleAssert( hDC );
    DbgPointerAssert( DrawEraseLine );

    Success = Polyline( hDC, ( CONST LPPOINT ) &DrawEraseLine->Draw, 2 );
    DbgAssert( Success );

    DrawEraseLine->Erase = DrawEraseLine->Draw;

    return Success;
}
Exemplo n.º 24
0
void CPolyCtl::CalcPoints(HDC hdc, const RECT& rc)
{
	const double pi = 3.14159265358979;
	POINT   ptCenter;
	// The radius is the hypotenuse 
	double  dblRadiusx = (rc.right - rc.left) / 2;
	double  dblRadiusy = (rc.bottom - rc.top) / 2;
	// angle is in radians, or radius lengths. 
	double  dblAngle = 4 * pi / 2;          // Start at the top
	double  dblDiff = 2 * pi / m_nSides;   // Angle each side will make

	ptCenter.x = (rc.left + rc.right) / 2;
	ptCenter.y = (rc.top + rc.bottom) / 2;

	POINT radianStart[2];
	radianStart[0].x = ptCenter.x;
	radianStart[0].y = ptCenter.y;
	radianStart[1].x = (long)(dblRadiusx * cos(0) + ptCenter.x + 0.5);
	radianStart[1].y = (long)(dblRadiusy * sin(0) + ptCenter.y + 0.5);

	Polyline(hdc, &radianStart[0], 2);

	// Calculate the points for each side
	int i = 0;
	for (; i < m_nSides; i++)
	{
		// When executing in the Visual C++ Debugger the output isn't directed to DebugView.
		ATLTRACE(_T("Angle in radians: %f\n"), dblAngle);

		m_arrPoint[i].x = (long)(dblRadiusx * cos(dblAngle) + ptCenter.x + 0.5);
		m_arrPoint[i].y = (long)(dblRadiusy * sin(dblAngle) + ptCenter.y + 0.5);

		if ( i > 0)
			DrawTriangle(hdc, ptCenter, m_arrPoint[i-1], m_arrPoint[i]);

		dblAngle += dblDiff;
	}
	DrawTriangle(hdc, ptCenter, m_arrPoint[i-1], m_arrPoint[0]);
}
Exemplo n.º 25
0
Arquivo: clb.c Projeto: mingpen/OpenNT
BOOL
EraseLine(
    IN HDC hDC,
    IN LPDRAW_ERASE_LINE DrawEraseLine
    )


/*++

Routine Description:

    EraseLine erasess the Erase line in the supplied DrawEraseLine structure.
    The EraseLine is set by the DrawLine routine.

Arguments:

    hDC             - Supplies a handle to the DC where the line should
                      be erased.
    DrawEraseLine   - Supplies a pointer to a DRAW_ERASE_LINE structure that
                      conatins the coordinates for the line to be erased.

Return Value:

    BOOL            - Returns TRUE if the line was succesfully erased.

--*/

{
    BOOL    Success;

    DbgHandleAssert( hDC );
    DbgPointerAssert( DrawEraseLine );

    Success = Polyline( hDC, ( CONST LPPOINT ) &DrawEraseLine->Erase, 2 );
    DbgAssert( Success );

    return Success;
}
Exemplo n.º 26
0
void EditToolbarUI::paintWindow(__in const RECT *rcWnd)
{
	const int DRAW_PEN_WIDTH = 2;

	RECT rc = { 0 };
	memcpy(&rc, rcWnd, sizeof(rc));

	HDC hRectDC = GetDC(m_hwnd);
	HPEN hDrawPen = CreatePen(PS_SOLID, DRAW_PEN_WIDTH, RGB(255, 0, 0));
	HGDIOBJ hPrevPen = SelectObject(hRectDC, hDrawPen);

	int x = rc.left;
	int y = rc.top;
	int cx = rc.right - rc.left;
	int cy = rc.bottom - rc.top;

	POINT ptArray[] = { { x, y },{ x + cx, y },{ x + cx, y + cy },{ x, y + cy },{ x, y }};
	Polyline(hRectDC, ptArray, 5);

	SelectObject(hRectDC, (HGDIOBJ)hPrevPen);
	DeleteObject(hDrawPen);
	ReleaseDC(m_hwnd, hRectDC);
}
Exemplo n.º 27
0
/// <param name="list">list of points</param>
/// <param name="count">number of points</param>
/// <param name="width">pen width for drawing line</param>
/// <param name="color">pen color</param>
void Canvas::DrawPolyline(const rect_t &rect, const rect_t &box, point_t list[], size_t count, meter_t width, color_t color)
{
	CPen pen;
	std::vector<POINT> pts;
	POINT pt = {0};

	for (size_t i = 0; i < count; i++)
	{
		pt.x = list[i].x + rect.x - box.x;
		pt.y = list[i].y + rect.y - box.y;
		pts.push_back(pt);
	}
	pen.CreatePen(PS_SOLID, width, color);
	HPEN hSave = SelectPen(pen);

	CRgn region;
	region.CreateRectRgn(rect.x, rect.y, rect.x + rect.wide, rect.y + rect.high);
	SelectClipRgn(region);

	Polyline(&pts[0], pts.size());
	SelectPen(hSave);
	SelectClipRgn(NULL);
}
Exemplo n.º 28
0
void
Win::paintStartup(HDC hdc)
{
	POINT pntArray[2];
	int width = GetSystemMetrics(SM_CXMAXIMIZED);
	pntArray[0].x=0;
	pntArray[0].y=80;
	pntArray[1].x=width;
	pntArray[1].y=80;
	Polyline(hdc, pntArray, 2);
	SelectObject(hdc, mediumfont);
	SetTextColor(hdc, RGB(0, 200, 0));
	TextOut(hdc, width/2, 50, startupmsg_1, strlen(startupmsg_1));
	SetTextColor(hdc, RGB(0, 0, 0));
	TextOut(hdc, width/2, 85, startupmsg_2, strlen(startupmsg_2));
	SelectObject(hdc, smallfont);
	TextOut(hdc, width/2, 120, startupmsg_3, strlen(startupmsg_3));
	TextOut(hdc, width/2, 140, startupmsg_4, strlen(startupmsg_4));
	SetTextColor(hdc, RGB(0, 0, 255));
	TextOut(hdc, width/2, 165, startupmsg_5, strlen(startupmsg_5));
	SetTextColor(hdc, RGB(0, 0, 0));
	TextOut(hdc, width/2, 185, startupmsg_6, strlen(startupmsg_6));
}
Exemplo n.º 29
0
VOID DrawLine(LPBYTE p, BYTE n)
{
	HDC hdc = GetDC(hWnd);
	HPEN hPen, hPenOld;
	hPen = CreatePen(PS_SOLID, 10, RGB(0, 0, 255));
	hPenOld = (HPEN)SelectObject(hdc, hPen);
	LPPOINT point;
	point = (LPPOINT)GlobalAlloc(
		GMEM_FIXED,
		sizeof(POINT)*n);
	for (BYTE i = 0; i<n; ++i)
	{
		point[i].x = PAI_WIDTH / 2 +
			(p[i] % X_NUM)*PAI_WIDTH;
		point[i].y = PAI_HEIGHT / 2 +
			(p[i] / X_NUM)*PAI_HEIGHT;
	}
	Polyline(hdc, point, n);
	GlobalFree(point);
	SelectObject(hdc, hPenOld);
	DeleteObject(hPen);
	ReleaseDC(hWnd, hdc);
}
Exemplo n.º 30
0
void wf_gdi_polyline(rdpContext* context, POLYLINE_ORDER* polyline)
{
	int i;
	POINT* pts;
	int org_rop2;
	HPEN hpen;
	HPEN org_hpen;
	uint32 pen_color;
	wfInfo* wfi = ((wfContext*) context)->wfi;

	pen_color = freerdp_color_convert_bgr(polyline->penColor, wfi->srcBpp, wfi->dstBpp, wfi->clrconv);

	hpen = CreatePen(0, 1, pen_color);
	org_rop2 = wf_set_rop2(wfi->drawing->hdc, polyline->bRop2);
	org_hpen = (HPEN) SelectObject(wfi->drawing->hdc, hpen);

	if (polyline->numPoints > 0)
	{
		pts = (POINT*) xmalloc(sizeof(POINT) * polyline->numPoints);

		for (i = 0; i < (int) polyline->numPoints; i++)
		{
			pts[i].x = polyline->points[i].x;
			pts[i].y = polyline->points[i].y;

			if (wfi->drawing == wfi->primary)
				wf_invalidate_region(wfi, pts[i].x, pts[i].y, pts[i].x + 1, pts[i].y + 1);
		}

		Polyline(wfi->drawing->hdc, pts, polyline->numPoints);
		xfree(pts);
	}

	SelectObject(wfi->drawing->hdc, org_hpen);
	wf_set_rop2(wfi->drawing->hdc, org_rop2);
	DeleteObject(hpen);
}