Exemple #1
0
BOOL AddPointInPolygon(CBCGPPointsArray& arPoly, const CBCGPPoint& pt)
{
	if (FindPointInPolygon (arPoly, pt) != -1)
	{
		return FALSE;
	}

	arPoly.Add (pt);

	return TRUE;
}
//*******************************************************************************
CBCGPGeometry* CBCGPChartInterLineColoringEffect::CreateGeometry(const CBCGPPointsArray& arOrgPoints, const CBCGPRect& rectBounds, 
																 BCGPChartFormatSeries::ChartCurveType curveType, BOOL bClip)
{
	CBCGPChartAxis* pXAxis = m_pSeries1->GetRelatedAxis(CBCGPChartSeries::AI_X);

	ASSERT_VALID(pXAxis);

	BOOL bIsVertical = pXAxis->IsVertical();
	CBCGPGeometry* pGeometry = NULL;

	CBCGPPointsArray arPoints;
	arPoints.Append(arOrgPoints);

	CBCGPPoint ptStart = arPoints[0];
	CBCGPPoint ptEnd = arPoints[arPoints.GetSize() - 1];

	CBCGPPoint ptClipCorrectionStart = ptStart;
	CBCGPPoint ptClipCorrectionEnd = ptEnd;

	if (bIsVertical)
	{
		if (bClip)
		{
			if (pXAxis->m_bReverseOrder)
			{
				ptClipCorrectionStart.y -= 1.;
				ptClipCorrectionEnd.y += 1.;
			}
			else
			{
				ptClipCorrectionStart.y += 1.;
				ptClipCorrectionEnd.y -= 1.;
			}
			
			ptStart = CBCGPPoint(rectBounds.left, ptClipCorrectionStart.y);
			ptEnd = CBCGPPoint(rectBounds.left, ptClipCorrectionEnd.y);
		}
		else
		{
			ptStart = CBCGPPoint(rectBounds.left, ptStart.y);
			ptEnd = CBCGPPoint(rectBounds.left, ptEnd.y);
		}
	}
	else
	{
		if (bClip)
		{
			if (pXAxis->m_bReverseOrder)
			{
				ptClipCorrectionStart.x += 1.;
				ptClipCorrectionEnd.x -= 1.;
			}
			else
			{
				ptClipCorrectionStart.x -= 1.;
				ptClipCorrectionEnd.x += 1.;
			}
			ptStart = CBCGPPoint(ptClipCorrectionStart.x, rectBounds.bottom);
			ptEnd = CBCGPPoint(ptClipCorrectionEnd.x, rectBounds.bottom);
		}
		else
		{
			ptStart = CBCGPPoint(ptStart.x, rectBounds.bottom);
			ptEnd = CBCGPPoint(ptEnd.x, rectBounds.bottom);
		}
	}

	if (curveType == BCGPChartFormatSeries::CCT_SPLINE || curveType == BCGPChartFormatSeries::CCT_SPLINE_HERMITE)
	{
		CBCGPSplineGeometry::BCGP_SPLINE_TYPE splineType = CBCGPSplineGeometry::BCGP_SPLINE_TYPE_KB;

		if (curveType == BCGPChartFormatSeries::CCT_SPLINE_HERMITE)
		{
			splineType = CBCGPSplineGeometry::BCGP_SPLINE_TYPE_HERMITE;
		}

		CBCGPComplexGeometry* pComplex = new CBCGPComplexGeometry() ;

		CBCGPSplineGeometry geometryTop(arOrgPoints, splineType, FALSE);

		pComplex->AddPoints(geometryTop.GetPoints(), CBCGPPolygonGeometry::BCGP_CURVE_TYPE_BEZIER);

		if (bClip)
		{
			pComplex->AddLine(ptClipCorrectionEnd);
		}

		pComplex->AddLine(ptEnd);
		pComplex->AddLine(ptStart);

		if (bClip)
		{
			pComplex->AddLine(ptClipCorrectionStart);
		}
	
		pComplex->SetClosed(TRUE);

		pGeometry = pComplex;
	}
	else
	{
		if (bClip)
		{
			arPoints.Add(ptClipCorrectionEnd);
		}

		arPoints.Add(ptEnd);
		arPoints.Add(ptStart);

		if (bClip)
		{
			arPoints.Add(ptClipCorrectionStart);
		}
		
		pGeometry = new CBCGPPolygonGeometry(arPoints);
	}

	return pGeometry;
}
//*******************************************************************************
BOOL CBCGPLinearGaugeImpl::GetRangeShape(CBCGPRect& rect, CBCGPPolygonGeometry& shape, double dblStartValue, double dblFinishValue,
	double dblStartWidth, double dblFinishWidth,
	double dblOffsetFromFrame, int nScale)
{
	rect.SetRectEmpty();
	shape.Clear();

	CBCGPPoint pt1;
	if (!ValueToPoint(dblStartValue, pt1, nScale))
	{
		return FALSE;
	}

	CBCGPPoint pt2;
	if (!ValueToPoint(dblFinishValue, pt2, nScale))
	{
		return FALSE;
	}

	const double scaleRatio = GetScaleRatioMid();

	if (dblStartWidth == 0.)
	{
		CBCGPGaugeScaleObject* pScale = GetScale(nScale);
		if (pScale != NULL)
		{
			dblStartWidth = pScale->m_dblMajorTickMarkSize + pScale->m_dblOffsetFromFrame;
		}
	}

	if (dblFinishWidth == 0.)
	{
		dblFinishWidth = dblStartWidth;
	}

	dblStartWidth *= scaleRatio;
	dblFinishWidth *= scaleRatio;	
	dblOffsetFromFrame *= scaleRatio;

	if (dblFinishWidth == dblStartWidth)
	{
		if (m_bIsVertical)
		{
			rect.left = pt1.x + dblOffsetFromFrame;
			rect.top = pt1.y;
			rect.right = pt1.x + dblStartWidth + dblOffsetFromFrame;
			rect.bottom = pt2.y;
		}
		else
		{
			rect.left = pt1.x;
			rect.top = pt1.y + dblOffsetFromFrame;
			rect.right = pt2.x;
			rect.bottom = pt1.y + dblStartWidth + dblOffsetFromFrame;
		}
	}
	else
	{
		CBCGPPointsArray arPoints;

		if (m_bIsVertical)
		{
			arPoints.Add(CBCGPPoint(pt1.x + dblOffsetFromFrame, pt1.y));
			arPoints.Add(CBCGPPoint(pt2.x + dblOffsetFromFrame, pt2.y));
			arPoints.Add(CBCGPPoint(pt2.x + dblOffsetFromFrame + dblFinishWidth, pt2.y));
			arPoints.Add(CBCGPPoint(pt1.x + dblOffsetFromFrame + dblStartWidth, pt1.y));
		}
		else
		{
			arPoints.Add(CBCGPPoint(pt1.x, pt1.y + dblOffsetFromFrame));
			arPoints.Add(CBCGPPoint(pt2.x, pt2.y + dblOffsetFromFrame));
			arPoints.Add(CBCGPPoint(pt2.x, pt2.y + dblOffsetFromFrame + dblFinishWidth));
			arPoints.Add(CBCGPPoint(pt1.x, pt1.y + dblOffsetFromFrame + dblStartWidth));
		}

		shape.SetPoints(arPoints);
	}

	return TRUE;
}
//*******************************************************************************
void CBCGPLinearGaugeImpl::CreatePointerPoints(CBCGPPointsArray& arPoints, int nPointerIndex, BOOL bShadow)
{
	if (m_rect.IsRectEmpty())
	{
		return;
	}

	CBCGPLinearGaugePointer* pData = DYNAMIC_DOWNCAST(CBCGPLinearGaugePointer, m_arData[nPointerIndex]);
	if (pData == NULL)
	{
		ASSERT(FALSE);
		return;
	}

	CBCGPGaugeScaleObject* pScale = GetScale(pData->GetScale());
	if (pScale == NULL)
	{
		ASSERT(FALSE);
		return;
	}

	const double scaleRatio = GetScaleRatioMid();

	double dblValue = pData->m_nAnimTimerID != 0 ? pData->m_dblAnimatedValue : pData->m_dblValue;

	double dblSizeMax = max(pScale->m_dblMajorTickMarkSize, 2. * pScale->m_dblMinorTickMarkSize) * scaleRatio;
	double dblSize = dblSizeMax;
	if (dblSize == 0)
	{
		dblSize = 8. * scaleRatio;
	}

	double dblSizePerc = bcg_clamp(pData->m_dblSize, 0.0, 1.0);
	if (dblSizePerc != 0.0)
	{
		dblSize = max(dblSize * dblSizePerc, 2.0);
	}

	CBCGPPoint point;

	if (!ValueToPoint(dblValue, point, pData->GetScale()))
	{
		return;
	}

	double offset = max(pScale->m_dblMajorTickMarkSize, pScale->m_dblMinorTickMarkSize) * scaleRatio;
	offset = max(offset, m_dblMaxRangeSize);

	double x = point.x;
	double y = point.y;

	if (dblSize < dblSizeMax && pData->GetPosition() != CBCGPLinearGaugePointer::BCGP_GAUGE_POSITION_NEAR)
	{
		double dblSizeDelta = dblSizeMax - dblSize;
		if (pData->GetPosition() == CBCGPLinearGaugePointer::BCGP_GAUGE_POSITION_CENTER)
		{
			dblSizeDelta /= 2.0;
		}

		if (m_bIsVertical)
		{
			x += dblSizeDelta;
		}
		else
		{
			y += dblSizeDelta;
		}
	}

	if (bShadow)
	{
		x += 2. * m_sizeScaleRatio.cx;
		y += 2. * m_sizeScaleRatio.cy;
	}

	const double delta = pData->m_dblWidth == 0 ? dblSize / 2 : (pData->m_dblWidth * scaleRatio) / 2;

	switch (pData->GetStyle())
	{
	case CBCGPLinearGaugePointer::BCGP_GAUGE_NEEDLE_TRIANGLE:
		if (m_bIsVertical)
		{
			arPoints.Add(CBCGPPoint(x, y - delta));
			arPoints.Add(CBCGPPoint(x, y + delta));
			arPoints.Add(CBCGPPoint(x + dblSize, y));
		}
		else
		{
			arPoints.Add(CBCGPPoint(x + delta, y));
			arPoints.Add(CBCGPPoint(x - delta, y));
			arPoints.Add(CBCGPPoint(x, y + dblSize));
		}
		break;

	case CBCGPLinearGaugePointer::BCGP_GAUGE_NEEDLE_TRIANGLE_INV:
		if (m_bIsVertical)
		{
			arPoints.Add(CBCGPPoint(x + dblSize, y - delta));
			arPoints.Add(CBCGPPoint(x + dblSize, y + delta));
			arPoints.Add(CBCGPPoint(x, y));
		}
		else
		{
			arPoints.Add(CBCGPPoint(x + delta, y + dblSize));
			arPoints.Add(CBCGPPoint(x - delta, y + dblSize));
			arPoints.Add(CBCGPPoint(x, y));
		}
		break;

	case CBCGPLinearGaugePointer::BCGP_GAUGE_NEEDLE_RECT:
	case CBCGPLinearGaugePointer::BCGP_GAUGE_NEEDLE_CIRCLE:
		if (m_bIsVertical)
		{
			arPoints.Add(CBCGPPoint(x, y + delta));
			arPoints.Add(CBCGPPoint(x, y - delta));

			arPoints.Add(CBCGPPoint(x + dblSize, y - delta));
			arPoints.Add(CBCGPPoint(x + dblSize, y + delta));
		}
		else
		{
			arPoints.Add(CBCGPPoint(x + delta, y + dblSize));
			arPoints.Add(CBCGPPoint(x - delta, y + dblSize));

			arPoints.Add(CBCGPPoint(x - delta, y));
			arPoints.Add(CBCGPPoint(x + delta, y));
		}
		break;

	case CBCGPLinearGaugePointer::BCGP_GAUGE_NEEDLE_DIAMOND:
		if (m_bIsVertical)
		{
			arPoints.Add(CBCGPPoint(x + .5 * dblSize, y + delta));
			arPoints.Add(CBCGPPoint(x, y));

			arPoints.Add(CBCGPPoint(x + .5 * dblSize, y - delta));
			arPoints.Add(CBCGPPoint(x + dblSize, y));
		}
		else
		{
			arPoints.Add(CBCGPPoint(x, y + dblSize));
			arPoints.Add(CBCGPPoint(x - delta, y + .5 * dblSize));

			arPoints.Add(CBCGPPoint(x, y));
			arPoints.Add(CBCGPPoint(x + delta, y + .5 * dblSize));
		}
	}
}
//**********************************************************************************************************
void CBCGPLinearGaugeImpl::OnDrawTickMark(CBCGPGraphicsManager* pGM, const CBCGPPoint& ptFrom, const CBCGPPoint& ptTo, 
											CBCGPGaugeScaleObject::BCGP_TICKMARK_STYLE style, BOOL bMajor, 
											double dblVal, int nScale, 
											const CBCGPBrush& brFillIn, const CBCGPBrush& brOutlineIn)
{
	ASSERT_VALID(pGM);

	CBCGPGaugeScaleObject* pScale = GetScale(nScale);
	if (pScale == NULL)
	{
		ASSERT(FALSE);
		return;
	}

	const double scaleRatio = GetScaleRatioMid();
	const double dblSize = (bMajor ? pScale->m_dblMajorTickMarkSize : pScale->m_dblMinorTickMarkSize) * scaleRatio;

	const CBCGPGaugeColoredRangeObject* pRange = GetColoredRangeByValue(dblVal, nScale, BCGP_GAUGE_RANGE_TICKMARK_COLOR);

	const CBCGPBrush& brFill = (pRange != NULL && !pRange->m_brTickMarkFill.IsEmpty()) ?
		pRange->m_brTickMarkFill : (brFillIn.IsEmpty() ? m_Colors.m_brTickMarkFill : brFillIn);

	const CBCGPBrush& brOutline = (pRange != NULL && !pRange->m_brTickMarkOutline.IsEmpty()) ?
		pRange->m_brTickMarkOutline : (brOutlineIn.IsEmpty() ? m_Colors.m_brTickMarkOutline : brOutlineIn);

	switch (style)
	{
	case CBCGPGaugeScaleObject::BCGP_TICKMARK_LINE:
		pGM->DrawLine(ptFrom, ptTo, brOutline, scaleRatio);
		break;

	case CBCGPGaugeScaleObject::BCGP_TICKMARK_TRIANGLE:
	case CBCGPGaugeScaleObject::BCGP_TICKMARK_TRIANGLE_INV:
	case CBCGPGaugeScaleObject::BCGP_TICKMARK_BOX:
		{
			CBCGPPointsArray arPoints;
			
			const double dblWidth = (style == CBCGPGaugeScaleObject::BCGP_TICKMARK_BOX) ?
				(dblSize / 4.) : (bMajor ? (dblSize * 2. / 3.) : (dblSize / 2.));

			const double dx = m_bIsVertical ? dblSize : max(dblWidth * .5, 3);
			const double dy = m_bIsVertical ? max(dblWidth * .5, 3) : dblSize;

			double x = ptTo.x;
			double y = ptTo.y;

			switch (style)
			{
			case CBCGPGaugeScaleObject::BCGP_TICKMARK_TRIANGLE:
				if (m_bIsVertical)
				{
					arPoints.Add(CBCGPPoint(x - dx, y - dy));
					arPoints.Add(CBCGPPoint(x - dx, y + dy));
					arPoints.Add(CBCGPPoint(x, y));
				}
				else
				{
					arPoints.Add(CBCGPPoint(x + dx, y - dy));
					arPoints.Add(CBCGPPoint(x - dx, y - dy));
					arPoints.Add(CBCGPPoint(x, y));
				}
				break;

			case CBCGPGaugeScaleObject::BCGP_TICKMARK_TRIANGLE_INV:
				if (m_bIsVertical)
				{
					arPoints.Add(CBCGPPoint(x, y - dy));
					arPoints.Add(CBCGPPoint(x, y + dy));
					arPoints.Add(CBCGPPoint(x - dx, y));
				}
				else
				{
					arPoints.Add(CBCGPPoint(x + dx, y));
					arPoints.Add(CBCGPPoint(x - dx, y));
					arPoints.Add(CBCGPPoint(x, y - dy));
				}
				break;

			case CBCGPGaugeScaleObject::BCGP_TICKMARK_BOX:
				if (m_bIsVertical)
				{
					arPoints.Add(CBCGPPoint(x - dx, y - dy));
					arPoints.Add(CBCGPPoint(x - dx, y + dy));

					arPoints.Add(CBCGPPoint(x, y + dy));
					arPoints.Add(CBCGPPoint(x, y - dy));
				}
				else
				{
					arPoints.Add(CBCGPPoint(x + dx, y - dy));
					arPoints.Add(CBCGPPoint(x - dx, y - dy));

					arPoints.Add(CBCGPPoint(x - dx, y));
					arPoints.Add(CBCGPPoint(x + dx, y));
				}
				break;
			}

			CBCGPPolygonGeometry rgn(arPoints);

			pGM->FillGeometry(rgn, brFill);
			pGM->DrawGeometry(rgn, brOutline, scaleRatio);
		}
		break;

	case CBCGPGaugeScaleObject::BCGP_TICKMARK_CIRCLE:
		{
			CBCGPPoint ptCenter(
				.5 * (ptFrom.x + ptTo.x),
				.5 * (ptFrom.y + ptTo.y));

			const double dblRadius = bMajor ? (dblSize / 2.) : (dblSize / 4.);

			CBCGPEllipse ellipse(ptCenter, dblRadius, dblRadius);

			pGM->FillEllipse(ellipse, brFill);
			pGM->DrawEllipse(ellipse, brOutline, scaleRatio);

			if (scaleRatio == 1.0 && !pGM->IsSupported(BCGP_GRAPHICS_MANAGER_ANTIALIAS))
			{
				CBCGPEllipse ellipse1(ptCenter, dblRadius - 1., dblRadius - 1.);
				pGM->DrawEllipse(ellipse1, brOutline);
			}
		}
		break;
	}
}
Exemple #6
0
//*******************************************************************************
void CBCGPKnob::CreatePointerPoints(double dblRadius,
                                    CBCGPPointsArray& arPoints,
                                    int nPointerIndex, BOOL bShadow)
{
    if (m_rect.IsRectEmpty())
    {
        return;
    }

    CBCGPRect rect = m_rect;

    CBCGPKnobPointer* pData = DYNAMIC_DOWNCAST(CBCGPKnobPointer, m_arData[nPointerIndex]);
    if (pData == NULL)
    {
        ASSERT(FALSE);
        return;
    }

    CBCGPCircularGaugeScale* pScale = GetScale(pData->GetScale());
    if (pScale == NULL)
    {
        ASSERT(FALSE);
        return;
    }

    const double scaleRatio = GetScaleRatioMid();

    double dblValue = pData->IsAnimated() ? pData->GetAnimatedValue() : pData->GetValue();

    double dblOffset = bcg_clamp(pData->GetOffsetFromCenter(), 0.0, 1.0);
    if (dblOffset == 0.0)
    {
        dblOffset = dblRadius * .5;
    }
    else
    {
        dblOffset = dblRadius * bcg_clamp(dblOffset, 0.5, 1.0);
    }

    double dblAngle = bcg_deg2rad(pScale->GetStartAngle()) - bcg_deg2rad(pScale->GetStartAngle() - pScale->GetFinishAngle()) * (dblValue - pScale->GetStart()) / (pScale->GetFinish() - pScale->GetStart());
    dblAngle = bcg_normalize_rad (dblAngle);

    if (bShadow)
    {
        rect.OffsetRect(2 * m_sizeScaleRatio.cx, 2 * m_sizeScaleRatio.cy);
    }

    CBCGPPoint center((rect.left + rect.right) / 2.0, (rect.top + rect.bottom) / 2.0);

    const double angleCos  = cos(dblAngle);
    const double angleSin  = sin(dblAngle);

    double dblWidth = bcg_clamp(pData->GetWidth(), 0.0, dblRadius / 10.0);
    const double dblPointerAngle = dblAngle - M_PI_2;

    switch (pData->GetStyle())
    {
    case CBCGPKnobPointer::BCGP_KNOB_POINTER_HANDLE:
    {
        dblRadius -= .2 * scaleRatio;
        double dblExtend = (dblRadius * .9);
        double dblSize = dblRadius + dblExtend;
        center.x -= angleCos * dblExtend;
        center.y += angleSin * dblExtend;

        if (dblWidth == 0.0)
        {
            dblWidth = dblRadius / 3.0;
        }

        dblWidth *= 0.5;

        if (dblWidth < 1.0)
        {
            arPoints.Add(center);

            arPoints.Add(CBCGPPoint(
                             center.x + angleCos * dblSize,
                             center.y - angleSin * dblSize));
        }
        else
        {
            double dblArrowLen = max(2.0 * dblWidth, 10.0 * scaleRatio);
            dblSize -= dblArrowLen;

            const double dx = cos(dblPointerAngle) * dblWidth;
            const double dy = -sin(dblPointerAngle) * dblWidth;

            arPoints.Add(CBCGPPoint(center.x + dx, center.y + dy));

            arPoints.Add(CBCGPPoint(center.x - dx, center.y - dy));

            const CBCGPPoint pt1(
                center.x + angleCos * dblSize - dx,
                center.y - angleSin * dblSize - dy);

            const CBCGPPoint pt2(
                center.x + angleCos * dblSize + dx,
                center.y - angleSin * dblSize + dy);

            arPoints.Add(pt1);

            arPoints.Add(CBCGPPoint(
                             center.x + angleCos * (dblSize + dblArrowLen),
                             center.y - angleSin * (dblSize + dblArrowLen)));

            arPoints.Add(pt2);
        }
    }
    break;

    case CBCGPKnobPointer::BCGP_KNOB_POINTER_LINE:
    {
        if (bShadow)
        {
            return;
        }

        if (dblWidth == 0.0)
        {
            dblWidth = 2. * scaleRatio;
        }

        const double dx = cos(dblPointerAngle) * dblWidth;
        const double dy = -sin(dblPointerAngle) * dblWidth;

        arPoints.Add(CBCGPPoint(center.x + angleCos * dblOffset - dx, center.y - angleSin * dblOffset - dy));
        arPoints.Add(CBCGPPoint(center.x + angleCos * dblOffset + dx, center.y - angleSin * dblOffset + dy));

        dblOffset = dblRadius - 4. * scaleRatio;

        arPoints.Add(CBCGPPoint(center.x + angleCos * dblOffset + dx, center.y - angleSin * dblOffset + dy));
        arPoints.Add(CBCGPPoint(center.x + angleCos * dblOffset - dx, center.y - angleSin * dblOffset - dy));
    }
    break;

    case CBCGPKnobPointer::BCGP_KNOB_POINTER_CIRCLE:
    {
        if (bShadow)
        {
            return;
        }

        if (dblWidth == 0.0)
        {
            dblWidth = max(2. * scaleRatio, dblRadius / 8);
        }

        dblOffset = dblRadius - 6. * scaleRatio - dblWidth;

        arPoints.Add(CBCGPPoint(center.x + angleCos * dblOffset, center.y - angleSin * dblOffset));
        arPoints.Add(CBCGPPoint(dblWidth, dblWidth));
    }
    break;
    }
}