void TetrisWidget::drawTextCentered(const Rect & inRect, const std::string & inText, int inFontSize, const RGBColor & inColor)
{
    if (!mPainter.get())
    {
        throw std::logic_error("Painter is not set.");
    }

    RestorePainter restorePainter(*mPainter);
    QPainter & painter(*mPainter);

    // Set the new pen
    painter.setPen(QColor(inColor.red(), inColor.green(), inColor.blue()));

    // Paint the stats title
    QFont textFont(painter.font());
    textFont.setPointSize(inFontSize);
    textFont.setBold(true);
    painter.setFont(textFont);

    int textWidth = painter.fontMetrics().width(inText.c_str());
    int textHeight = painter.fontMetrics().height();

    int x = inRect.left() + (inRect.width()  - textWidth)/2;
    int y = inRect.top()  + (inRect.height() - textHeight)/2;
    QRect theTextRect(x, y, game()->gameGrid().columnCount() * squareWidth(),squareHeight());
    painter.drawText(theTextRect, inText.c_str());
}
void TetrisWidget::drawTextRightAligned(const Rect & inRect, const std::string & inText, int inFontSize, const RGBColor & inColor)
{
    if (!mPainter.get())
    {
        throw std::logic_error("Painter is not set.");
    }

    RestorePainter restorePainter(*mPainter);
    QPainter & painter(*mPainter);

    painter.setPen(QColor(inColor.red(), inColor.green(), inColor.blue()));

    // Paint the stats title
    QFont textFont(painter.font());
    textFont.setPointSize(inFontSize);
    textFont.setBold(true);
    painter.setFont(textFont);

    int textWidth = painter.fontMetrics().width(inText.c_str());
    int textHeight = painter.fontMetrics().height();

    int x = inRect.right() - textWidth - margin();
    int y = inRect.top()  + (inRect.height() - textHeight)/2;
    drawText(x, y, inText);
}
void TetrisWidget::paintSquare(const Rect & inRect, const RGBColor & inColor)
{
    if (!mPainter.get())
    {
        throw std::logic_error("Painter is not set.");
    }

    RestorePainter restorePainter(*mPainter);

    QColor color(inColor.red(), inColor.green(), inColor.blue());
    int x = inRect.x();
    int y = inRect.y();
    int width = inRect.width();
    int height = inRect.height();

    mPainter->fillRect(x + 1, y + 1, width - 2, height - 2, color);

    mPainter->setPen(color.light());
    mPainter->drawLine(x, y + height - 1, x, y);
    mPainter->drawLine(x, y, x + width - 1, y);

    mPainter->setPen(color.dark());
    mPainter->drawLine(x + 1, y + height - 1, x + width - 1, y + height - 1);
    mPainter->drawLine(x + width - 1, y + height - 1, x + width - 1, y + 1);
}
示例#4
0
void BinaryFormatter::writeAttr(std::ostream& into, const SumoXMLAttr attr, const RGBColor& val) {
    BinaryFormatter::writeAttrHeader(into, attr, BF_COLOR);
    FileHelpers::writeByte(into, val.red());
    FileHelpers::writeByte(into, val.green());
    FileHelpers::writeByte(into, val.blue());
    FileHelpers::writeByte(into, val.alpha());
}
示例#5
0
/* Test the method 'interpolate'*/
TEST(RGBColor, test_interpolate) {	
	RGBColor color1 = RGBColor(1,2,3);
	RGBColor color2 = RGBColor(2,4,2);
	RGBColor colorResult = RGBColor::interpolate(color1, color2, 0.5);
	EXPECT_FLOAT_EQ(SUMOReal(1.5), colorResult.red());
	EXPECT_FLOAT_EQ(SUMOReal(3), colorResult.green());
	EXPECT_FLOAT_EQ(SUMOReal(2.5), colorResult.blue());
}
示例#6
0
/* Test the method 'interpolate'*/
TEST(RGBColor, test_interpolate) {	
	RGBColor color1 = RGBColor(1,2,3);
	RGBColor color2 = RGBColor(3,4,1);
	RGBColor colorResult = RGBColor::interpolate(color1, color2, 0.5);
	EXPECT_EQ(2, colorResult.red());
	EXPECT_EQ(3, colorResult.green());
	EXPECT_EQ(2, colorResult.blue());
}
示例#7
0
JSValue jsRGBColorGreen(ExecState* exec, JSValue slotBase, const Identifier&)
{
    JSRGBColor* castedThis = static_cast<JSRGBColor*>(asObject(slotBase));
    UNUSED_PARAM(exec);
    RGBColor* imp = static_cast<RGBColor*>(castedThis->impl());
    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->green()));
    return result;
}
示例#8
0
/* Test the method 'interpolate' with a weight of 0 and lower*/
TEST(RGBColor, test_interpolate_weight_0) {	
	RGBColor color1 = RGBColor(1,2,3);
	RGBColor color2 = RGBColor(2,4,2);
	RGBColor colorResult = RGBColor::interpolate(color1, color2, 0);
	RGBColor colorResult2 = RGBColor::interpolate(color1, color2, -1000);
	EXPECT_TRUE(colorResult==colorResult2);
	EXPECT_EQ(1, colorResult.red());
	EXPECT_EQ(2, colorResult.green());
	EXPECT_EQ(3, colorResult.blue());
}
示例#9
0
/* Test the method 'interpolate' with a weight of 1 and higher*/
TEST(RGBColor, test_interpolate_weight_1) {	
	RGBColor color1 = RGBColor(1,2,3);
	RGBColor color2 = RGBColor(2,4,2);
	RGBColor colorResult = RGBColor::interpolate(color1, color2, 1);
	RGBColor colorResult2 = RGBColor::interpolate(color1, color2, 1000);
	EXPECT_TRUE(colorResult==colorResult2);
	EXPECT_FLOAT_EQ(SUMOReal(2), colorResult.red());
	EXPECT_FLOAT_EQ(SUMOReal(4), colorResult.green());
	EXPECT_FLOAT_EQ(SUMOReal(2), colorResult.blue());
}
void TetrisWidget::drawLine(int x1, int y1, int x2, int y2, int inPenWidth, const RGBColor & inColor)
{
    if (!mPainter.get())
    {
        throw std::logic_error("Painter is not set.");
    }
    RestorePainter restorePainter(*mPainter);

    mPainter->setPen(QColor(inColor.red(), inColor.green(), inColor.blue()));
    mPainter->drawLine(x1, y1, x2, y2);
}
static v8::Handle<v8::Value> greenAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
{
    RGBColor* imp = V8RGBColor::toNative(info.Holder());
    RefPtr<CSSPrimitiveValue> result = imp->green();
    v8::Handle<v8::Value> wrapper = result.get() ? v8::Handle<v8::Value>(DOMDataStore::getWrapper(result.get(), info.GetIsolate())) : v8Undefined();
    if (wrapper.IsEmpty()) {
        wrapper = toV8(result.get(), info.Holder(), info.GetIsolate());
        if (!wrapper.IsEmpty())
            V8DOMWrapper::setNamedHiddenReference(info.Holder(), "green", wrapper);
    }
    return wrapper;
}
示例#12
0
/* Test the method 'interpolate' with a weight of 1 and higher*/
TEST(RGBColor, test_interpolate_weight_1) {	
	RGBColor color1 = RGBColor(1,2,3);
	RGBColor color2 = RGBColor(3,4,1);
	RGBColor colorResult = RGBColor::interpolate(color1, color2, 0.5);
	RGBColor colorResult1 = RGBColor::interpolate(color1, color2, 0);
	RGBColor colorResult2 = RGBColor::interpolate(color1, color2, 1);
	EXPECT_TRUE(color1==colorResult1);
	EXPECT_TRUE(color2==colorResult2);
	EXPECT_EQ(2, colorResult.red());
	EXPECT_EQ(3, colorResult.green());
	EXPECT_EQ(2, colorResult.blue());
}
示例#13
0
HSVColor RGB2HSV(const RGBColor & rgb)
{
	double r = rgb.red() / 255.0;
	double g = rgb.green() / 255.0;
	double b = rgb.blue() / 255.0;

	// Calculate chroma
	double maxColor = Max(r, g, b);
	double minColor = Min(r, g, b);
	double chroma = maxColor - minColor;
	
	// Calculate hue
	double hue = 0;
	if (chroma != 0)
	{
		if (maxColor == r)
		{
			hue = (g - b / chroma) * 60.0;
		}
		else if (maxColor == g)
		{
			hue = (2 + (b - r) / chroma) * 60.0;
		}
		else // maxColor == b
		{
			assert(maxColor == b);
			hue = (4 + (r - g) / chroma) * 60.0;
		}
		if (hue < 0)
		{
			hue += 360.0;
		}
		assert(hue >= 0 && hue < 360);
	}

	double saturation = 0;
    if (maxColor != 0)
    {
        saturation = chroma / maxColor;
    }
	assert(saturation >= 0 && saturation <= 1);

	double value = maxColor;
	assert(value >= 0 && value <= 1);

	return HSVColor(static_cast<int>(0.5 + hue),
				    static_cast<int>(0.5 + 100.0 * saturation),
					static_cast<int>(0.5 + 100.0 * value));
}
示例#14
0
void
GLHelper::drawText(const std::string& text, const Position& pos,
                   const double layer, const double size,
                   const RGBColor& col, const double angle, const int align,
                   double width) {
    if (width <= 0) {
        width = size;
    }
    if (!initFont()) {
        return;
    };
    glPushMatrix();
    glAlphaFunc(GL_GREATER, 0.5);
    glEnable(GL_ALPHA_TEST);
    glTranslated(pos.x(), pos.y(), layer);
    glScaled(width / myFontSize, size / myFontSize, 1.);
    glRotated(-angle, 0, 0, 1);
    fonsSetAlign(myFont, align == 0 ? FONS_ALIGN_CENTER | FONS_ALIGN_MIDDLE : align);
    fonsSetColor(myFont, glfonsRGBA(col.red(), col.green(), col.blue(), col.alpha()));
    fonsDrawText(myFont, 0., 0., text.c_str(), nullptr);
    glPopMatrix();
}
示例#15
0
FXColor
MFXUtils::getFXColor(const RGBColor& col) {
    return FXRGBA(col.red(), col.green(), col.blue(), col.alpha());
}
示例#16
0
void
GLHelper::setColor(const RGBColor& c) {
    glColor4ub(c.red(), c.green(), c.blue(), c.alpha());
}
示例#17
0
/* Test the method 'parseColor' with a longer String*/
TEST(RGBColor, test_parseColor_with_a_long_string) {
	RGBColor color = RGBColor::parseColor("1,2,3,5,432test");
	EXPECT_FLOAT_EQ(SUMOReal(1), color.red());
	EXPECT_FLOAT_EQ(SUMOReal(2), color.green());
	EXPECT_FLOAT_EQ(SUMOReal(3), color.blue());
}
示例#18
0
/* Test the method 'parseColor'*/
TEST(RGBColor, test_parseColor) {
	RGBColor color = RGBColor::parseColor("1,2,3");
	EXPECT_FLOAT_EQ(SUMOReal(1), color.red());
	EXPECT_FLOAT_EQ(SUMOReal(2), color.green());
	EXPECT_FLOAT_EQ(SUMOReal(3), color.blue());
}
示例#19
0
/* Test the method 'parseColor'*/
TEST(RGBColor, test_parseColor) {
	RGBColor color = RGBColor::parseColor("0,1,255");
	EXPECT_EQ(0, color.red());
	EXPECT_EQ(1, color.green());
	EXPECT_EQ(255, color.blue());
}