C++ (Cpp) BGradientConic::SetCenter Examples

Example #1

File: GradientsView.cpp Project: mmanley/Antares

void
GradientsView::DrawConic(BRect update)
{
	BGradientConic gradient;
	rgb_color c;
	c.red = 255;
	c.green = 0;
	c.blue = 0;
	gradient.AddColor(c, 0);
	c.red = 0;
	c.green = 255;
	c.blue = 0;
	gradient.AddColor(c, 127);
	c.red = 0;
	c.green = 0;
	c.blue = 255;
	gradient.AddColor(c, 255);

	// RoundRect
	SetHighColor(0, 0, 0);
	FillRoundRect(BRect(10, 10, 110, 110), 5, 5);
	gradient.SetCenter(BPoint(170, 60));
	FillRoundRect(BRect(120, 10, 220, 110), 5, 5, gradient);

	// Rect
	SetHighColor(0, 0, 0);
	FillRect(BRect(10, 120, 110, 220));
	gradient.SetCenter(BPoint(170, 170));
	FillRect(BRect(120, 120, 220, 220), gradient);

	// Triangle
	SetHighColor(0, 0, 0);
	FillTriangle(BPoint(60, 230), BPoint(10, 330), BPoint(110, 330));
	gradient.SetCenter(BPoint(170, 280));
	FillTriangle(BPoint(170, 230), BPoint(120, 330), BPoint(220, 330), 
		gradient);

	// Ellipse
	SetHighColor(0, 0, 0);
	FillEllipse(BPoint(60, 390), 50, 50);
	gradient.SetCenter(BPoint(170, 390));
	FillEllipse(BPoint(170, 390), 50, 50, gradient);
}

Example #2

File: View.cpp Project: mmanley/Antares

//! converts a gradient from local *drawing* to screen coordinate system
void
View::ConvertToScreenForDrawing(BGradient* gradient) const
{
    switch(gradient->GetType()) {
    case BGradient::TYPE_LINEAR: {
        BGradientLinear* linear = (BGradientLinear*) gradient;
        BPoint start = linear->Start();
        BPoint end = linear->End();
        fDrawState->Transform(&start);
        ConvertToScreen(&start);
        fDrawState->Transform(&end);
        ConvertToScreen(&end);
        linear->SetStart(start);
        linear->SetEnd(end);
        linear->SortColorStopsByOffset();
        break;
    }
    case BGradient::TYPE_RADIAL: {
        BGradientRadial* radial = (BGradientRadial*) gradient;
        BPoint center = radial->Center();
        fDrawState->Transform(&center);
        ConvertToScreen(&center);
        radial->SetCenter(center);
        radial->SortColorStopsByOffset();
        break;
    }
    case BGradient::TYPE_RADIAL_FOCUS: {
        BGradientRadialFocus* radialFocus = (BGradientRadialFocus*) gradient;
        BPoint center = radialFocus->Center();
        BPoint focal = radialFocus->Focal();
        fDrawState->Transform(&center);
        ConvertToScreen(&center);
        fDrawState->Transform(&focal);
        ConvertToScreen(&focal);
        radialFocus->SetCenter(center);
        radialFocus->SetFocal(focal);
        radialFocus->SortColorStopsByOffset();
        break;
    }
    case BGradient::TYPE_DIAMOND: {
        BGradientDiamond* diamond = (BGradientDiamond*) gradient;
        BPoint center = diamond->Center();
        fDrawState->Transform(&center);
        ConvertToScreen(&center);
        diamond->SetCenter(center);
        diamond->SortColorStopsByOffset();
        break;
    }
    case BGradient::TYPE_CONIC: {
        BGradientConic* conic = (BGradientConic*) gradient;
        BPoint center = conic->Center();
        fDrawState->Transform(&center);
        ConvertToScreen(&center);
        conic->SetCenter(center);
        conic->SortColorStopsByOffset();
        break;
    }
    case BGradient::TYPE_NONE: {
        break;
    }
    }
}

Example #3

File: LinkReceiver.cpp Project: DonCN/haiku

status_t
LinkReceiver::ReadGradient(BGradient** _gradient)
{
	GTRACE(("LinkReceiver::ReadGradient\n"));

	BGradient::Type gradientType;
	int32 colorsCount;
	Read(&gradientType, sizeof(BGradient::Type));
	status_t status = Read(&colorsCount, sizeof(int32));
	if (status != B_OK)
		return status;

	BGradient* gradient = gradient_for_type(gradientType);
	if (!gradient)
		return B_NO_MEMORY;

	*_gradient = gradient;

	if (colorsCount > 0) {
		BGradient::ColorStop stop;
		for (int i = 0; i < colorsCount; i++) {
			if ((status = Read(&stop, sizeof(BGradient::ColorStop))) != B_OK)
				return status;
			if (!gradient->AddColorStop(stop, i))
				return B_NO_MEMORY;
		}
	}

	switch (gradientType) {
		case BGradient::TYPE_LINEAR:
		{
			GTRACE(("LinkReceiver::ReadGradient> type == TYPE_LINEAR\n"));
			BGradientLinear* linear = (BGradientLinear*)gradient;
			BPoint start;
			BPoint end;
			Read(&start, sizeof(BPoint));
			if ((status = Read(&end, sizeof(BPoint))) != B_OK)
				return status;
			linear->SetStart(start);
			linear->SetEnd(end);
			return B_OK;
		}
		case BGradient::TYPE_RADIAL:
		{
			GTRACE(("LinkReceiver::ReadGradient> type == TYPE_RADIAL\n"));
			BGradientRadial* radial = (BGradientRadial*)gradient;
			BPoint center;
			float radius;
			Read(&center, sizeof(BPoint));
			if ((status = Read(&radius, sizeof(float))) != B_OK)
				return status;
			radial->SetCenter(center);
			radial->SetRadius(radius);
			return B_OK;
		}
		case BGradient::TYPE_RADIAL_FOCUS:
		{
			GTRACE(("LinkReceiver::ReadGradient> type == TYPE_RADIAL_FOCUS\n"));
			BGradientRadialFocus* radialFocus =
				(BGradientRadialFocus*)gradient;
			BPoint center;
			BPoint focal;
			float radius;
			Read(&center, sizeof(BPoint));
			Read(&focal, sizeof(BPoint));
			if ((status = Read(&radius, sizeof(float))) != B_OK)
				return status;
			radialFocus->SetCenter(center);
			radialFocus->SetFocal(focal);
			radialFocus->SetRadius(radius);
			return B_OK;
		}
		case BGradient::TYPE_DIAMOND:
		{
			GTRACE(("LinkReceiver::ReadGradient> type == TYPE_DIAMOND\n"));
			BGradientDiamond* diamond = (BGradientDiamond*)gradient;
			BPoint center;
			if ((status = Read(&center, sizeof(BPoint))) != B_OK)
				return status;
			diamond->SetCenter(center);
			return B_OK;
		}
		case BGradient::TYPE_CONIC:
		{
			GTRACE(("LinkReceiver::ReadGradient> type == TYPE_CONIC\n"));
			BGradientConic* conic = (BGradientConic*)gradient;
			BPoint center;
			float angle;
			Read(&center, sizeof(BPoint));
			if ((status = Read(&angle, sizeof(float))) != B_OK)
				return status;
			conic->SetCenter(center);
			conic->SetAngle(angle);
			return B_OK;
		}
		case BGradient::TYPE_NONE:
		{
			GTRACE(("LinkReceiver::ReadGradient> type == TYPE_NONE\n"));
			break;
		}
	}

	return B_ERROR;
}