void StyleHelper::verticalGradient(QPainter *painter, const QRect &spanRect, const QRect &clipRect)
{
QString key;
key.sprintf("mh_toolbar %d %d %d %d %d", spanRect.width(), spanRect.height(), clipRect.width(),
clipRect.height(), StyleHelper::baseColor().rgb());;
QPixmap pixmap;
QPainter *p = painter;
QRect rect = clipRect;
if (StyleHelper::usePixmapCache() && !QPixmapCache::find(key, pixmap)) {
pixmap = QPixmap(clipRect.size());
p = new QPainter(&pixmap);
rect = QRect(0, 0, clipRect.width(), clipRect.height());
}
QColor base = StyleHelper::baseColor();
QLinearGradient grad(spanRect.topRight(), spanRect.topLeft());
grad.setColorAt(0, highlightColor());
grad.setColorAt(0.301, base);
grad.setColorAt(1, shadowColor());
p->fillRect(rect, grad);
QColor light(255, 255, 255, 80);
p->setPen(light);
p->drawLine(rect.topRight() - QPoint(1, 0), rect.bottomRight() - QPoint(1, 0));
if (StyleHelper::usePixmapCache() && !QPixmapCache::find(key, pixmap)) {
painter->drawPixmap(clipRect.topLeft(), pixmap);
p->end();
delete p;
QPixmapCache::insert(key, pixmap);
}
}
void Scene::Draw()
{
TIME_PROFILE("Scene::Draw");
//float timeElapsed = SystemTimer::Instance()->FrameDelta();
shadowVolumes.clear();
if(NULL != sceneGlobalMaterial)
{
NMaterialProperty* propShadowColor = sceneGlobalMaterial->GetMaterialProperty(NMaterial::PARAM_SHADOW_COLOR);
if(NULL != propShadowColor)
{
DVASSERT(Shader::UT_FLOAT_VEC4 == propShadowColor->type);
float32* propDataPtr = (float32*)propShadowColor->data;
Color shadowColor(propDataPtr[0], propDataPtr[1], propDataPtr[2], propDataPtr[3]);
renderSystem->SetShadowRectColor(shadowColor);
}
}
uint64 time = SystemTimer::Instance()->AbsoluteMS();
if(imposterManager)
{
//imposterManager->ProcessQueue();
}
renderSystem->Render(clearBuffers);
//foliageSystem->DebugDrawVegetation();
drawTime = SystemTimer::Instance()->AbsoluteMS() - time;
}
QLinearGradient StyleHelper::statusBarGradient(const QRect &statusBarRect)
{
QLinearGradient grad(statusBarRect.topLeft(), QPoint(statusBarRect.center().x(), statusBarRect.bottom()));
QColor startColor = shadowColor().darker(164);
QColor endColor = baseColor().darker(130);
grad.setColorAt(0, startColor);
grad.setColorAt(1, endColor);
return grad;
}
//
// DESCRIPTION:
///////////////////////////////////////////////////////
MStatus ShadowMatte::compute(
const MPlug& plug,
MDataBlock& block )
{
if ((plug != aOutColor) && (plug.parent() != aOutColor) &&
(plug != aOutTransparency) && (plug.parent() != aOutTransparency))
return MS::kUnknownParameter;
MFloatVector shadowColor(0.0,0.0,0.0);
bool ViewFlag = block.inputValue( aViewColor ).asBool();
// get light list
MArrayDataHandle lightData = block.inputArrayValue( aLightData );
int numLights = lightData.elementCount();
// iterate through light list and get ambient/diffuse values
for( int count=1; count <= numLights; count++ )
{
MDataHandle currentLight = lightData.inputValue();
float lightShadow = currentLight.child(aLightShadowFraction).asFloat();
// shadow fraction tells how much an object is in shadow:
// (1) totally in shadow
// (0-1) partially in shadow
// (0) not in shadow
shadowColor[0] += lightShadow;
shadowColor[1] += lightShadow;
shadowColor[2] += lightShadow;
if( !lightData.next() ) break;
}
// set ouput color attribute
MFloatVector ghostColor(0.0,0.0,0.0);
MDataHandle outColorHandle = block.outputValue( aOutColor );
MFloatVector& outColor = outColorHandle.asFloatVector();
if (ViewFlag)
outColor = shadowColor;
else
outColor = ghostColor;
outColorHandle.setClean();
// set ouput transparency
MDataHandle outTransHandle = block.outputValue( aOutTransparency );
MFloatVector& outTrans = outTransHandle.asFloatVector();
outTrans = shadowColor;
outTransHandle.setClean();
return MS::kSuccess;
}
//----------------------------------------------------------------------------
void ReflectionsAndShadows::CreatePlanarShadow ()
{
Light* projector = new0 Light(Light::LT_POINT);
projector->Position = APoint(30.0f, -50.0f, 80.0f);
LightNode* projectorNode = new0 LightNode(projector);
mScene->AttachChild(projectorNode);
mPSEffect = new0 PlanarShadowEffect(1, mBiped);
Float4 shadowColor(0.0f, 0.0f, 0.0f, 0.5f);
mPSEffect->SetPlane(0, mPlane0);
mPSEffect->SetProjector(0, projector);
mPSEffect->SetShadowColor(0, shadowColor);
}
void PaintingItemPainter::paint(QNanoPainter *painter)
{
// Background
QNanoRadialGradient grad;
grad.setStartColor("#808080");
grad.setEndColor("#606060");
grad.setCenterPosition(width()/2, height()/2);
grad.setOuterRadius(qMax(width(), height())*0.6);
painter->setFillStyle(grad);
painter->setStrokeStyle("#F0F0F0");
painter->setLineWidth(1);
painter->beginPath();
painter->rect(0, 0, width(), height());
painter->fill();
painter->stroke();
// Draw painting line
if (m_paths.size() > 0) {
painter->setLineCap(QNanoPainter::CAP_ROUND);
painter->setLineJoin(QNanoPainter::JOIN_ROUND);
float lineWidth = QNanoPainter::mmToPx(2);
painter->setLineWidth(lineWidth);
for (int i=0; i<m_paths.count(); ++i) {
auto item = m_paths.at(i).data();
auto points = item->m_points;
if (points.count() > 0) {
QNanoColor shadowColor("#202020");
shadowColor.setAlpha(item->opacity() * 200);
painter->setStrokeStyle(shadowColor);
painter->setAntialias(10.0);
drawPathLine(points, QPoint(lineWidth*0.2, lineWidth*0.2));
QNanoColor lineColor("#F0D060");
lineColor.setAlpha(item->opacity() * 255);
painter->setStrokeStyle(lineColor);
painter->setAntialias(2.0);
drawPathLine(points, QPoint(0,0));
// If animation is still running, update
if (item->m_hideAnimation.state() == QAbstractAnimation::Running) {
emit update();
}
}
}
}
}
//----------------------------------------------------------------------------
void PlanarShadows::CreatePlanarShadow ()
{
#if 1
Light* projector = new0 Light(Light::LT_POINT);
projector->Position = APoint(152.0f, -55.0f, 53.0f);
#else
Light* projector = new0 Light(Light::LT_DIRECTIONAL);
projector->DVector = AVector(0.25f, 0.25f, -1.0f);
projector->DVector.Normalize();
#endif
mProjectorNode = new0 LightNode(projector);
mScene->AttachChild(mProjectorNode);
mPSEffect = new0 PlanarShadowEffect(2, mBiped);
Float4 shadowColor(0.0f, 0.0f, 0.0f, 0.5f);
mPSEffect->SetPlane(0, mPlane0);
mPSEffect->SetProjector(0, projector);
mPSEffect->SetShadowColor(0, shadowColor);
mPSEffect->SetPlane(1, mPlane1);
mPSEffect->SetProjector(1, projector);
mPSEffect->SetShadowColor(1, shadowColor);
}
void StyleHelper::horizontalGradient(QPainter *painter, const QRect &spanRect, const QRect &clipRect)
{
QString key;
key.sprintf("mh_toolbar %d %d %d %d %d", spanRect.width(), spanRect.height(),
clipRect.width(), clipRect.height(), StyleHelper::baseColor().rgb());
QPixmap pixmap;
QPainter *p = painter;
QRect rect = clipRect;
if (StyleHelper::usePixmapCache() && !QPixmapCache::find(key, pixmap)) {
pixmap = QPixmap(clipRect.size());
p = new QPainter(&pixmap);
rect = QRect(0, 0, clipRect.width(), clipRect.height());
}
QColor base = StyleHelper::baseColor();
QLinearGradient grad(rect.topLeft(), rect.bottomLeft());
grad.setColorAt(0, highlightColor().lighter(120));
grad.setColorAt(0.5, highlightColor());
grad.setColorAt(0.501, base);
grad.setColorAt(1, shadowColor());
p->fillRect(rect, grad);
/* QLinearGradient shadowGradient(spanRect.topLeft(), spanRect.topRight());
shadowGradient.setColorAt(0, QColor(0, 0, 0, 30));
QColor highlight = highlightColor().lighter(130);
highlight.setAlpha(100);
shadowGradient.setColorAt(0.7, highlight);
shadowGradient.setColorAt(1, QColor(0, 0, 0, 40));
p->fillRect(rect, shadowGradient);*/
if (StyleHelper::usePixmapCache() && !QPixmapCache::find(key, pixmap)) {
painter->drawPixmap(clipRect.topLeft(), pixmap);
p->end();
delete p;
QPixmapCache::insert(key, pixmap);
}
}
int Context2D::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QObject::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: changed((*reinterpret_cast< const QImage(*)>(_a[1]))); break;
case 1: save(); break;
case 2: restore(); break;
case 3: scale((*reinterpret_cast< qreal(*)>(_a[1])),(*reinterpret_cast< qreal(*)>(_a[2]))); break;
case 4: rotate((*reinterpret_cast< qreal(*)>(_a[1]))); break;
case 5: translate((*reinterpret_cast< qreal(*)>(_a[1])),(*reinterpret_cast< qreal(*)>(_a[2]))); break;
case 6: transform((*reinterpret_cast< qreal(*)>(_a[1])),(*reinterpret_cast< qreal(*)>(_a[2])),(*reinterpret_cast< qreal(*)>(_a[3])),(*reinterpret_cast< qreal(*)>(_a[4])),(*reinterpret_cast< qreal(*)>(_a[5])),(*reinterpret_cast< qreal(*)>(_a[6]))); break;
case 7: setTransform((*reinterpret_cast< qreal(*)>(_a[1])),(*reinterpret_cast< qreal(*)>(_a[2])),(*reinterpret_cast< qreal(*)>(_a[3])),(*reinterpret_cast< qreal(*)>(_a[4])),(*reinterpret_cast< qreal(*)>(_a[5])),(*reinterpret_cast< qreal(*)>(_a[6]))); break;
case 8: { CanvasGradient _r = createLinearGradient((*reinterpret_cast< qreal(*)>(_a[1])),(*reinterpret_cast< qreal(*)>(_a[2])),(*reinterpret_cast< qreal(*)>(_a[3])),(*reinterpret_cast< qreal(*)>(_a[4])));
if (_a[0]) *reinterpret_cast< CanvasGradient*>(_a[0]) = _r; } break;
case 9: { CanvasGradient _r = createRadialGradient((*reinterpret_cast< qreal(*)>(_a[1])),(*reinterpret_cast< qreal(*)>(_a[2])),(*reinterpret_cast< qreal(*)>(_a[3])),(*reinterpret_cast< qreal(*)>(_a[4])),(*reinterpret_cast< qreal(*)>(_a[5])),(*reinterpret_cast< qreal(*)>(_a[6])));
if (_a[0]) *reinterpret_cast< CanvasGradient*>(_a[0]) = _r; } break;
case 10: clearRect((*reinterpret_cast< qreal(*)>(_a[1])),(*reinterpret_cast< qreal(*)>(_a[2])),(*reinterpret_cast< qreal(*)>(_a[3])),(*reinterpret_cast< qreal(*)>(_a[4]))); break;
case 11: fillRect((*reinterpret_cast< qreal(*)>(_a[1])),(*reinterpret_cast< qreal(*)>(_a[2])),(*reinterpret_cast< qreal(*)>(_a[3])),(*reinterpret_cast< qreal(*)>(_a[4]))); break;
case 12: strokeRect((*reinterpret_cast< qreal(*)>(_a[1])),(*reinterpret_cast< qreal(*)>(_a[2])),(*reinterpret_cast< qreal(*)>(_a[3])),(*reinterpret_cast< qreal(*)>(_a[4]))); break;
case 13: beginPath(); break;
case 14: closePath(); break;
case 15: moveTo((*reinterpret_cast< qreal(*)>(_a[1])),(*reinterpret_cast< qreal(*)>(_a[2]))); break;
case 16: lineTo((*reinterpret_cast< qreal(*)>(_a[1])),(*reinterpret_cast< qreal(*)>(_a[2]))); break;
case 17: quadraticCurveTo((*reinterpret_cast< qreal(*)>(_a[1])),(*reinterpret_cast< qreal(*)>(_a[2])),(*reinterpret_cast< qreal(*)>(_a[3])),(*reinterpret_cast< qreal(*)>(_a[4]))); break;
case 18: bezierCurveTo((*reinterpret_cast< qreal(*)>(_a[1])),(*reinterpret_cast< qreal(*)>(_a[2])),(*reinterpret_cast< qreal(*)>(_a[3])),(*reinterpret_cast< qreal(*)>(_a[4])),(*reinterpret_cast< qreal(*)>(_a[5])),(*reinterpret_cast< qreal(*)>(_a[6]))); break;
case 19: arcTo((*reinterpret_cast< qreal(*)>(_a[1])),(*reinterpret_cast< qreal(*)>(_a[2])),(*reinterpret_cast< qreal(*)>(_a[3])),(*reinterpret_cast< qreal(*)>(_a[4])),(*reinterpret_cast< qreal(*)>(_a[5]))); break;
case 20: rect((*reinterpret_cast< qreal(*)>(_a[1])),(*reinterpret_cast< qreal(*)>(_a[2])),(*reinterpret_cast< qreal(*)>(_a[3])),(*reinterpret_cast< qreal(*)>(_a[4]))); break;
case 21: arc((*reinterpret_cast< qreal(*)>(_a[1])),(*reinterpret_cast< qreal(*)>(_a[2])),(*reinterpret_cast< qreal(*)>(_a[3])),(*reinterpret_cast< qreal(*)>(_a[4])),(*reinterpret_cast< qreal(*)>(_a[5])),(*reinterpret_cast< bool(*)>(_a[6]))); break;
case 22: fill(); break;
case 23: stroke(); break;
case 24: clip(); break;
case 25: { bool _r = isPointInPath((*reinterpret_cast< qreal(*)>(_a[1])),(*reinterpret_cast< qreal(*)>(_a[2])));
if (_a[0]) *reinterpret_cast< bool*>(_a[0]) = _r; } break;
case 26: drawImage((*reinterpret_cast< DomImage*(*)>(_a[1])),(*reinterpret_cast< qreal(*)>(_a[2])),(*reinterpret_cast< qreal(*)>(_a[3]))); break;
case 27: drawImage((*reinterpret_cast< DomImage*(*)>(_a[1])),(*reinterpret_cast< qreal(*)>(_a[2])),(*reinterpret_cast< qreal(*)>(_a[3])),(*reinterpret_cast< qreal(*)>(_a[4])),(*reinterpret_cast< qreal(*)>(_a[5]))); break;
case 28: drawImage((*reinterpret_cast< DomImage*(*)>(_a[1])),(*reinterpret_cast< qreal(*)>(_a[2])),(*reinterpret_cast< qreal(*)>(_a[3])),(*reinterpret_cast< qreal(*)>(_a[4])),(*reinterpret_cast< qreal(*)>(_a[5])),(*reinterpret_cast< qreal(*)>(_a[6])),(*reinterpret_cast< qreal(*)>(_a[7])),(*reinterpret_cast< qreal(*)>(_a[8])),(*reinterpret_cast< qreal(*)>(_a[9]))); break;
case 29: { ImageData _r = getImageData((*reinterpret_cast< qreal(*)>(_a[1])),(*reinterpret_cast< qreal(*)>(_a[2])),(*reinterpret_cast< qreal(*)>(_a[3])),(*reinterpret_cast< qreal(*)>(_a[4])));
if (_a[0]) *reinterpret_cast< ImageData*>(_a[0]) = _r; } break;
case 30: putImageData((*reinterpret_cast< ImageData(*)>(_a[1])),(*reinterpret_cast< qreal(*)>(_a[2])),(*reinterpret_cast< qreal(*)>(_a[3]))); break;
default: ;
}
_id -= 31;
}
#ifndef QT_NO_PROPERTIES
else if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast< qreal*>(_v) = globalAlpha(); break;
case 1: *reinterpret_cast< QString*>(_v) = globalCompositeOperation(); break;
case 2: *reinterpret_cast< QVariant*>(_v) = strokeStyle(); break;
case 3: *reinterpret_cast< QVariant*>(_v) = fillStyle(); break;
case 4: *reinterpret_cast< qreal*>(_v) = lineWidth(); break;
case 5: *reinterpret_cast< QString*>(_v) = lineCap(); break;
case 6: *reinterpret_cast< QString*>(_v) = lineJoin(); break;
case 7: *reinterpret_cast< qreal*>(_v) = miterLimit(); break;
case 8: *reinterpret_cast< qreal*>(_v) = shadowOffsetX(); break;
case 9: *reinterpret_cast< qreal*>(_v) = shadowOffsetY(); break;
case 10: *reinterpret_cast< qreal*>(_v) = shadowBlur(); break;
case 11: *reinterpret_cast< QString*>(_v) = shadowColor(); break;
}
_id -= 12;
} else if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 0: setGlobalAlpha(*reinterpret_cast< qreal*>(_v)); break;
case 1: setGlobalCompositeOperation(*reinterpret_cast< QString*>(_v)); break;
case 2: setStrokeStyle(*reinterpret_cast< QVariant*>(_v)); break;
case 3: setFillStyle(*reinterpret_cast< QVariant*>(_v)); break;
case 4: setLineWidth(*reinterpret_cast< qreal*>(_v)); break;
case 5: setLineCap(*reinterpret_cast< QString*>(_v)); break;
case 6: setLineJoin(*reinterpret_cast< QString*>(_v)); break;
case 7: setMiterLimit(*reinterpret_cast< qreal*>(_v)); break;
case 8: setShadowOffsetX(*reinterpret_cast< qreal*>(_v)); break;
case 9: setShadowOffsetY(*reinterpret_cast< qreal*>(_v)); break;
case 10: setShadowBlur(*reinterpret_cast< qreal*>(_v)); break;
case 11: setShadowColor(*reinterpret_cast< QString*>(_v)); break;
}
_id -= 12;
} else if (_c == QMetaObject::ResetProperty) {
_id -= 12;
} else if (_c == QMetaObject::QueryPropertyDesignable) {
_id -= 12;
} else if (_c == QMetaObject::QueryPropertyScriptable) {
_id -= 12;
} else if (_c == QMetaObject::QueryPropertyStored) {
_id -= 12;
} else if (_c == QMetaObject::QueryPropertyEditable) {
_id -= 12;
} else if (_c == QMetaObject::QueryPropertyUser) {
_id -= 12;
}
#endif // QT_NO_PROPERTIES
return _id;
}
bool OsmAnd::MapRasterizer_P::updatePaint(
const Context& context,
SkPaint& paint,
const MapStyleEvaluationResult& evalResult,
const PaintValuesSet valueSetSelector,
const bool isArea)
{
const auto& env = context.env;
bool ok = true;
int valueDefId_color = -1;
int valueDefId_strokeWidth = -1;
int valueDefId_cap = -1;
int valueDefId_pathEffect = -1;
switch (valueSetSelector)
{
case PaintValuesSet::Layer_minus2:
valueDefId_color = env->styleBuiltinValueDefs->id_OUTPUT_COLOR__2;
valueDefId_strokeWidth = env->styleBuiltinValueDefs->id_OUTPUT_STROKE_WIDTH__2;
valueDefId_cap = env->styleBuiltinValueDefs->id_OUTPUT_CAP__2;
valueDefId_pathEffect = env->styleBuiltinValueDefs->id_OUTPUT_PATH_EFFECT__2;
break;
case PaintValuesSet::Layer_minus1:
valueDefId_color = env->styleBuiltinValueDefs->id_OUTPUT_COLOR__1;
valueDefId_strokeWidth = env->styleBuiltinValueDefs->id_OUTPUT_STROKE_WIDTH__1;
valueDefId_cap = env->styleBuiltinValueDefs->id_OUTPUT_CAP__1;
valueDefId_pathEffect = env->styleBuiltinValueDefs->id_OUTPUT_PATH_EFFECT__1;
break;
case PaintValuesSet::Layer_0:
valueDefId_color = env->styleBuiltinValueDefs->id_OUTPUT_COLOR_0;
valueDefId_strokeWidth = env->styleBuiltinValueDefs->id_OUTPUT_STROKE_WIDTH_0;
valueDefId_cap = env->styleBuiltinValueDefs->id_OUTPUT_CAP_0;
valueDefId_pathEffect = env->styleBuiltinValueDefs->id_OUTPUT_PATH_EFFECT_0;
break;
case PaintValuesSet::Layer_1:
valueDefId_color = env->styleBuiltinValueDefs->id_OUTPUT_COLOR;
valueDefId_strokeWidth = env->styleBuiltinValueDefs->id_OUTPUT_STROKE_WIDTH;
valueDefId_cap = env->styleBuiltinValueDefs->id_OUTPUT_CAP;
valueDefId_pathEffect = env->styleBuiltinValueDefs->id_OUTPUT_PATH_EFFECT;
break;
case PaintValuesSet::Layer_2:
valueDefId_color = env->styleBuiltinValueDefs->id_OUTPUT_COLOR_2;
valueDefId_strokeWidth = env->styleBuiltinValueDefs->id_OUTPUT_STROKE_WIDTH_2;
valueDefId_cap = env->styleBuiltinValueDefs->id_OUTPUT_CAP_2;
valueDefId_pathEffect = env->styleBuiltinValueDefs->id_OUTPUT_PATH_EFFECT_2;
break;
case PaintValuesSet::Layer_3:
valueDefId_color = env->styleBuiltinValueDefs->id_OUTPUT_COLOR_3;
valueDefId_strokeWidth = env->styleBuiltinValueDefs->id_OUTPUT_STROKE_WIDTH_3;
valueDefId_cap = env->styleBuiltinValueDefs->id_OUTPUT_CAP_3;
valueDefId_pathEffect = env->styleBuiltinValueDefs->id_OUTPUT_PATH_EFFECT_3;
break;
case PaintValuesSet::Layer_4:
valueDefId_color = env->styleBuiltinValueDefs->id_OUTPUT_COLOR_4;
valueDefId_strokeWidth = env->styleBuiltinValueDefs->id_OUTPUT_STROKE_WIDTH_4;
valueDefId_cap = env->styleBuiltinValueDefs->id_OUTPUT_CAP_4;
valueDefId_pathEffect = env->styleBuiltinValueDefs->id_OUTPUT_PATH_EFFECT_4;
break;
case PaintValuesSet::Layer_5:
valueDefId_color = env->styleBuiltinValueDefs->id_OUTPUT_COLOR_5;
valueDefId_strokeWidth = env->styleBuiltinValueDefs->id_OUTPUT_STROKE_WIDTH_5;
valueDefId_cap = env->styleBuiltinValueDefs->id_OUTPUT_CAP_5;
valueDefId_pathEffect = env->styleBuiltinValueDefs->id_OUTPUT_PATH_EFFECT_5;
break;
default:
return false;
}
if (isArea)
{
if (!evalResult.contains(valueDefId_color) && !evalResult.contains(env->styleBuiltinValueDefs->id_OUTPUT_SHADER))
return false;
paint.setColorFilter(nullptr);
paint.setShader(nullptr);
paint.setLooper(nullptr);
paint.setStyle(SkPaint::kStrokeAndFill_Style);
paint.setStrokeWidth(0);
}
else
{
float stroke;
ok = evalResult.getFloatValue(valueDefId_strokeWidth, stroke);
if (!ok || stroke <= 0.0f)
return false;
paint.setColorFilter(nullptr);
paint.setShader(nullptr);
paint.setLooper(nullptr);
paint.setStyle(SkPaint::kStroke_Style);
paint.setStrokeWidth(stroke);
QString cap;
ok = evalResult.getStringValue(valueDefId_cap, cap);
if (!ok || cap.isEmpty() || cap.compare(QLatin1String("BUTT"), Qt::CaseInsensitive) == 0)
paint.setStrokeCap(SkPaint::kButt_Cap);
else if (cap.compare(QLatin1String("ROUND"), Qt::CaseInsensitive) == 0)
paint.setStrokeCap(SkPaint::kRound_Cap);
else if (cap.compare(QLatin1String("SQUARE"), Qt::CaseInsensitive) == 0)
paint.setStrokeCap(SkPaint::kSquare_Cap);
else
paint.setStrokeCap(SkPaint::kButt_Cap);
QString encodedPathEffect;
ok = evalResult.getStringValue(valueDefId_pathEffect, encodedPathEffect);
if (!ok || encodedPathEffect.isEmpty())
{
paint.setPathEffect(nullptr);
}
else
{
SkPathEffect* pathEffect = nullptr;
ok = obtainPathEffect(encodedPathEffect, pathEffect);
if (ok && pathEffect)
paint.setPathEffect(pathEffect);
}
}
SkColor color = SK_ColorTRANSPARENT;
evalResult.getIntegerValue(valueDefId_color, color);
paint.setColor(color);
if (valueSetSelector == PaintValuesSet::Layer_1)
{
QString shader;
ok = evalResult.getStringValue(env->styleBuiltinValueDefs->id_OUTPUT_SHADER, shader);
if (ok && !shader.isEmpty())
{
SkBitmapProcShader* shaderObj = nullptr;
if (obtainBitmapShader(env, shader, shaderObj) && shaderObj)
{
// SKIA requires non-transparent color
if (paint.getColor() == SK_ColorTRANSPARENT)
paint.setColor(SK_ColorWHITE);
paint.setShader(static_cast<SkShader*>(shaderObj))->unref();
}
}
}
// do not check shadow color here
if (context.shadowMode == MapPresentationEnvironment::ShadowMode::OneStep && valueSetSelector == PaintValuesSet::Layer_1)
{
ColorARGB shadowColor(0x00000000);
ok = evalResult.getIntegerValue(env->styleBuiltinValueDefs->id_OUTPUT_SHADOW_COLOR, shadowColor.argb);
if (!ok || shadowColor.isTransparent())
shadowColor = context.shadowColor;
float shadowRadius = 0.0f;
evalResult.getFloatValue(env->styleBuiltinValueDefs->id_OUTPUT_SHADOW_RADIUS, shadowRadius);
if (shadowRadius > 0.0f && !shadowColor.isTransparent())
{
paint.setLooper(SkBlurDrawLooper::Create(
shadowColor.toSkColor(),
SkBlurMaskFilter::ConvertRadiusToSigma(shadowRadius),
0,
0))->unref();
}
}
return true;
}
void drawDial(const QStyleOptionSlider *option, QPainter *painter)
{
QPalette pal = option->palette;
QColor buttonColor = pal.button().color();
const int width = option->rect.width();
const int height = option->rect.height();
const bool enabled = option->state & QStyle::State_Enabled;
qreal r = qMin(width, height) / 2;
r -= r/50;
const qreal penSize = r/20.0;
painter->save();
// Draw notches
if (option->subControls & QStyle::SC_DialTickmarks) {
painter->setPen(option->palette.dark().color().darker(120));
painter->drawLines(QStyleHelper::calcLines(option));
}
// Cache dial background
BEGIN_STYLE_PIXMAPCACHE(QString::fromLatin1("qdial"));
const qreal d_ = r / 6;
const qreal dx = option->rect.x() + d_ + (width - 2 * r) / 2 + 1;
const qreal dy = option->rect.y() + d_ + (height - 2 * r) / 2 + 1;
QRectF br = QRectF(dx + 0.5, dy + 0.5,
int(r * 2 - 2 * d_ - 2),
int(r * 2 - 2 * d_ - 2));
buttonColor.setHsv(buttonColor .hue(),
qMin(140, buttonColor .saturation()),
qMax(180, buttonColor.value()));
QColor shadowColor(0, 0, 0, 20);
if (enabled) {
// Drop shadow
qreal shadowSize = qMax(1.0, penSize/2.0);
QRectF shadowRect= br.adjusted(-2*shadowSize, -2*shadowSize,
2*shadowSize, 2*shadowSize);
QRadialGradient shadowGradient(shadowRect.center().x(),
shadowRect.center().y(), shadowRect.width()/2.0,
shadowRect.center().x(), shadowRect.center().y());
shadowGradient.setColorAt(qreal(0.91), QColor(0, 0, 0, 40));
shadowGradient.setColorAt(qreal(1.0), Qt::transparent);
p->setBrush(shadowGradient);
p->setPen(Qt::NoPen);
p->translate(shadowSize, shadowSize);
p->drawEllipse(shadowRect);
p->translate(-shadowSize, -shadowSize);
// Main gradient
QRadialGradient gradient(br.center().x() - br.width()/3, dy,
br.width()*1.3, br.center().x(),
br.center().y() - br.height()/2);
gradient.setColorAt(0, buttonColor.lighter(110));
gradient.setColorAt(qreal(0.5), buttonColor);
gradient.setColorAt(qreal(0.501), buttonColor.darker(102));
gradient.setColorAt(1, buttonColor.darker(115));
p->setBrush(gradient);
} else {
p->setBrush(Qt::NoBrush);
}
p->setPen(QPen(buttonColor.darker(280)));
p->drawEllipse(br);
p->setBrush(Qt::NoBrush);
p->setPen(buttonColor.lighter(110));
p->drawEllipse(br.adjusted(1, 1, -1, -1));
if (option->state & QStyle::State_HasFocus) {
QColor highlight = pal.highlight().color();
highlight.setHsv(highlight.hue(),
qMin(160, highlight.saturation()),
qMax(230, highlight.value()));
highlight.setAlpha(127);
p->setPen(QPen(highlight, 2.0));
p->setBrush(Qt::NoBrush);
p->drawEllipse(br.adjusted(-1, -1, 1, 1));
}
END_STYLE_PIXMAPCACHE
QPointF dp = calcRadialPos(option, qreal(0.70));
buttonColor = buttonColor.lighter(104);
buttonColor.setAlphaF(qreal(0.8));
const qreal ds = r/qreal(7.0);
QRectF dialRect(dp.x() - ds, dp.y() - ds, 2*ds, 2*ds);
QRadialGradient dialGradient(dialRect.center().x() + dialRect.width()/2,
dialRect.center().y() + dialRect.width(),
dialRect.width()*2,
dialRect.center().x(), dialRect.center().y());
dialGradient.setColorAt(1, buttonColor.darker(140));
dialGradient.setColorAt(qreal(0.4), buttonColor.darker(120));
dialGradient.setColorAt(0, buttonColor.darker(110));
if (penSize > 3.0) {
painter->setPen(QPen(QColor(0, 0, 0, 25), penSize));
painter->drawLine(calcRadialPos(option, qreal(0.90)), calcRadialPos(option, qreal(0.96)));
}
painter->setBrush(dialGradient);
painter->setPen(QColor(255, 255, 255, 150));
painter->drawEllipse(dialRect.adjusted(-1, -1, 1, 1));
painter->setPen(QColor(0, 0, 0, 80));
painter->drawEllipse(dialRect);
painter->restore();
}
void FindIndicator::draw(GraphicsContext& graphicsContext, const IntRect& /*dirtyRect*/)
{
#if ENABLE(LEGACY_FIND_INDICATOR_STYLE)
for (size_t i = 0; i < m_textRectsInSelectionRectCoordinates.size(); ++i) {
FloatRect textRect = m_textRectsInSelectionRectCoordinates[i];
textRect.move(leftBorderThickness, topBorderThickness);
FloatRect outerPathRect = inflateRect(textRect, horizontalOutsetToCenterOfLightBorder, verticalOutsetToCenterOfLightBorder);
FloatRect innerPathRect = inflateRect(textRect, horizontalPaddingInsideLightBorder, verticalPaddingInsideLightBorder);
{
GraphicsContextStateSaver stateSaver(graphicsContext);
graphicsContext.setShadow(FloatSize(shadowOffsetX, shadowOffsetY), shadowBlurRadius, shadowColor(), ColorSpaceSRGB);
graphicsContext.setFillColor(lightBorderColor(), ColorSpaceDeviceRGB);
graphicsContext.fillPath(pathWithRoundedRect(outerPathRect, cornerRadius));
}
{
GraphicsContextStateSaver stateSaver(graphicsContext);
graphicsContext.clip(pathWithRoundedRect(innerPathRect, cornerRadius));
RefPtr<Gradient> gradient = Gradient::create(FloatPoint(innerPathRect.x(), innerPathRect.y()), FloatPoint(innerPathRect.x(), innerPathRect.maxY()));
gradient->addColorStop(0, gradientLightColor());
gradient->addColorStop(1, gradientDarkColor());
graphicsContext.setFillGradient(gradient.releaseNonNull());
graphicsContext.fillRect(outerPathRect);
}
{
GraphicsContextStateSaver stateSaver(graphicsContext);
graphicsContext.translate(FloatSize(roundf(leftBorderThickness), roundf(topBorderThickness)));
IntRect contentImageRect = enclosingIntRect(m_textRectsInSelectionRectCoordinates[i]);
m_contentImage->paint(graphicsContext, m_contentImageScaleFactor, contentImageRect.location(), contentImageRect);
}
}
#else
for (auto& textRect : m_textRectsInSelectionRectCoordinates) {
FloatRect blurRect = textRect;
blurRect.move(flatShadowBlurRadius + flatStyleHorizontalBorder, flatShadowBlurRadius + flatStyleVerticalBorder);
FloatRect outerPathRect = inflateRect(blurRect, flatStyleHorizontalBorder, flatStyleVerticalBorder);
{
GraphicsContextStateSaver stateSaver(graphicsContext);
graphicsContext.setShadow(FloatSize(), flatRimShadowBlurRadius, flatRimShadowColor(), ColorSpaceSRGB);
graphicsContext.setFillColor(flatHighlightColor(), ColorSpaceSRGB);
graphicsContext.fillRect(outerPathRect);
graphicsContext.setShadow(FloatSize(flatShadowOffsetX, flatShadowOffsetY), flatShadowBlurRadius, flatDropShadowColor(), ColorSpaceSRGB);
graphicsContext.fillRect(outerPathRect);
}
{
GraphicsContextStateSaver stateSaver(graphicsContext);
graphicsContext.translate(FloatSize(flatShadowBlurRadius + flatStyleHorizontalBorder, flatShadowBlurRadius + flatStyleVerticalBorder));
IntRect contentImageRect = enclosingIntRect(textRect);
m_contentImage->paint(graphicsContext, m_contentImageScaleFactor, contentImageRect.location(), contentImageRect);
}
}
#endif
}
static
void drawDial ( const QStyleOptionSlider *option, QPainter *painter )
{
QPalette pal = option->palette;
QColor buttonColor = pal.button().color();
const int width = option->rect.width();
const int height = option->rect.height();
const bool enabled = option->state & QStyle::State_Enabled;
qreal r = qMin(width, height) / 2;
r -= r/50;
const qreal penSize = r/20.0;
painter->save();
painter->setRenderHint(QPainter::Antialiasing);
// Draw notches
if (option->subControls & QStyle::SC_DialTickmarks) {
painter->setPen(option->palette.dark().color().darker(120));
painter->drawLines(calcLines(option));
}
// Cache dial background
QString a = QString::fromLatin1("qdial");
QRect rect = option->rect;
QPixmap internalPixmapCache;
QImage imageCache;
QPainter *p = painter;
QString unique = uniqueName((a), option, option->rect.size());
int txType = painter->deviceTransform().type() | painter->worldTransform().type();
bool doPixmapCache = txType <= QTransform::TxTranslate;
if (doPixmapCache && QPixmapCache::find(unique, internalPixmapCache)) {
painter->drawPixmap(option->rect.topLeft(), internalPixmapCache);
} else {
if (doPixmapCache) {
rect.setRect(0, 0, option->rect.width(), option->rect.height());
imageCache = QImage(option->rect.size(), QImage::Format_ARGB32_Premultiplied);
imageCache.fill(0);
p = new QPainter(&imageCache);
}
//--BEGIN_STYLE_PIXMAPCACHE(QString::fromLatin1("qdial"));
p->setRenderHint(QPainter::Antialiasing);
const qreal d_ = r / 6;
const qreal dx = option->rect.x() + d_ + (width - 2 * r) / 2 + 1;
const qreal dy = option->rect.y() + d_ + (height - 2 * r) / 2 + 1;
QRectF br = QRectF(dx + 0.5, dy + 0.5,
int(r * 2 - 2 * d_ - 2),
int(r * 2 - 2 * d_ - 2));
buttonColor.setHsv(buttonColor .hue(),
qMin(140, buttonColor .saturation()),
qMax(180, buttonColor.value()));
QColor shadowColor(0, 0, 0, 20);
if (enabled) {
// Drop shadow
qreal shadowSize = qMax(1.0, penSize/2.0);
QRectF shadowRect= br.adjusted(-2*shadowSize, -2*shadowSize,
2*shadowSize, 2*shadowSize);
QRadialGradient shadowGradient(shadowRect.center().x(),
shadowRect.center().y(), shadowRect.width()/2.0,
shadowRect.center().x(), shadowRect.center().y());
shadowGradient.setColorAt(qreal(0.91), QColor(0, 0, 0, 40));
shadowGradient.setColorAt(qreal(1.0), Qt::transparent);
p->setBrush(shadowGradient);
p->setPen(Qt::NoPen);
p->translate(shadowSize, shadowSize);
p->drawEllipse(shadowRect);
p->translate(-shadowSize, -shadowSize);
// Main gradient
QRadialGradient gradient(br.center().x() - br.width()/3, dy,
br.width()*1.3, br.center().x(),
br.center().y() - br.height()/2);
gradient.setColorAt(0, buttonColor.lighter(110));
gradient.setColorAt(qreal(0.5), buttonColor);
gradient.setColorAt(qreal(0.501), buttonColor.darker(102));
gradient.setColorAt(1, buttonColor.darker(115));
p->setBrush(gradient);
} else {
p->setBrush(Qt::NoBrush);
}
p->setPen(QPen(buttonColor.darker(280)));
p->drawEllipse(br);
p->setBrush(Qt::NoBrush);
p->setPen(buttonColor.lighter(110));
p->drawEllipse(br.adjusted(1, 1, -1, -1));
if (option->state & QStyle::State_HasFocus) {
QColor highlight = pal.highlight().color();
highlight.setHsv(highlight.hue(),
qMin(160, highlight.saturation()),
qMax(230, highlight.value()));
highlight.setAlpha(127);
p->setPen(QPen(highlight, 2.0));
p->setBrush(Qt::NoBrush);
p->drawEllipse(br.adjusted(-1, -1, 1, 1));
}
//--END_STYLE_PIXMAPCACHE
if (doPixmapCache) {
p->end();
delete p;
internalPixmapCache = QPixmap::fromImage(imageCache);
painter->drawPixmap(option->rect.topLeft(), internalPixmapCache);
QPixmapCache::insert(unique, internalPixmapCache);
}
}
QPointF dp = calcRadialPos(option, qreal(0.70));
buttonColor = buttonColor.lighter(104);
buttonColor.setAlphaF(qreal(0.8));
const qreal ds = r/qreal(7.0);
QRectF dialRect(dp.x() - ds, dp.y() - ds, 2*ds, 2*ds);
QRadialGradient dialGradient(dialRect.center().x() + dialRect.width()/2,
dialRect.center().y() + dialRect.width(),
dialRect.width()*2,
dialRect.center().x(), dialRect.center().y());
dialGradient.setColorAt(1, buttonColor.darker(140));
dialGradient.setColorAt(qreal(0.4), buttonColor.darker(120));
dialGradient.setColorAt(0, buttonColor.darker(110));
if (penSize > 3.0) {
painter->setPen(QPen(QColor(0, 0, 0, 25), penSize));
painter->drawLine(calcRadialPos(option, qreal(0.90)), calcRadialPos(option, qreal(0.96)));
}
painter->setBrush(dialGradient);
painter->setPen(QColor(255, 255, 255, 150));
painter->drawEllipse(dialRect.adjusted(-1, -1, 1, 1));
painter->setPen(QColor(0, 0, 0, 80));
painter->drawEllipse(dialRect);
painter->restore();
}
void Font::renderText(const std::string& text,
const Vec2i& position,
const Vec4d& color)
{
bool cached;
uint listIndex;
// Haben wir diesen String schon im Cache?
stdext::hash_map<std::string, StringCacheEntry>::iterator entry = stringCache.find(text);
if(entry != stringCache.end())
{
// Ja, ist schon im Cache!
listIndex = entry->second.listIndex;
entry->second.lastTimeUsed = SDL_GetTicks();
cached = true;
}
else
{
// Der String muss neu generiert werden, weil er nicht im Cache ist.
// Ist noch Platz im Cache?
if(stringCache.size() < numLists)
{
// Ja, es ist noch Platz. Freie Liste suchen!
listIndex = 0;
while(!(listFree & (1 << listIndex))) listIndex++;
// Diese Liste ist jetzt belegt.
listFree &= ~(1 << listIndex);
}
else
{
// Der älteste Eintrag wird überschrieben.
uint minTime = ~0;
stdext::hash_map<std::string, StringCacheEntry>::iterator oldestEntry;
for(stdext::hash_map<std::string, StringCacheEntry>::iterator i = stringCache.begin(); i != stringCache.end(); ++i)
{
if(i->second.lastTimeUsed < minTime)
{
minTime = i->second.lastTimeUsed;
oldestEntry = i;
}
}
// Listenindex merken und den Eintrag löschen
listIndex = oldestEntry->second.listIndex;
stringCache.erase(oldestEntry);
}
// neuen Eintrag erstellen
StringCacheEntry newEntry;
newEntry.lastTimeUsed = SDL_GetTicks();
newEntry.listIndex = listIndex;
stringCache[text] = newEntry;
cached = false;
}
if(!cached)
{
glNewList(listBase + listIndex, GL_COMPILE);
renderTextPure(text);
glEndList();
}
glPushMatrix();
glTranslated(position.x, position.y, 0.0);
// Schatten zeichnen, falls erwünscht
if(options.shadows)
{
std::vector<Vec2i> samples;
if(options.shadows == 2) { samples.push_back(Vec2i(2, 1)); samples.push_back(Vec2i(1, 2)); }
else if(options.shadows == 1) { samples.push_back(Vec2i(1, 0)); samples.push_back(Vec2i(0, 1)); }
int numSamples = static_cast<int>(samples.size());
Vec4d shadowColor(0.0, 0.0, 0.0, 0.7 / numSamples);
shadowColor.a *= color.a;
for(int i = 0; i < numSamples; i++)
{
glColor4dv(shadowColor);
glPushMatrix();
glTranslated(samples[i].x, samples[i].y, 0.0);
glCallList(listBase + listIndex);
glPopMatrix();
}
}
// String zeichnen
glColor4dv(color);
glCallList(listBase + listIndex);
glPopMatrix();
}
/**
* Reimplemented from QGraphicsItem::paint.
* Draws the AssociationLine and also takes care of highlighting active point or line.
*/
void AssociationLine::paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget)
{
Q_UNUSED(widget)
QPen _pen = pen();
const QColor orig = _pen.color().lighter();
QColor invertedColor(orig.green(), orig.blue(), orig.red());
if (invertedColor == _pen.color()) {
// Ensure different color.
invertedColor.setRed((invertedColor.red() + 50) % 256);
}
invertedColor.setAlpha(150);
int sz = m_points.size();
if (sz < 1) {
// not enough points - do nothing
return;
}
QPointF savedStart = m_points.first();
QPointF savedEnd = m_points.last();
// modify the m_points array not to include the Symbol, the value depends on Symbol
if (m_startSymbol) {
QPointF newStart = m_startSymbol->mapToParent(m_startSymbol->symbolEndPoints().first);
m_points[0] = newStart;
}
if (m_endSymbol) {
QPointF newEnd = m_endSymbol->mapToParent(m_endSymbol->symbolEndPoints().first);
m_points[sz - 1] = newEnd;
}
painter->setPen(_pen);
painter->setBrush(Qt::NoBrush);
painter->drawPath(path());
if (option->state & QStyle::State_Selected) {
// make the association broader in the selected state
QPainterPathStroker stroker;
stroker.setWidth(3.0);
QPainterPath outline = stroker.createStroke(path());
QColor shadowColor(Qt::lightGray);
shadowColor.setAlpha(80);
QBrush shadowBrush(shadowColor);
painter->setBrush(shadowBrush);
painter->setPen(Qt::NoPen);
painter->drawPath(outline);
// set color for selected painting
_pen.setColor(Qt::blue);
QRectF circle(0, 0, SelectedPointDiameter, SelectedPointDiameter);
painter->setBrush(_pen.color());
painter->setPen(Qt::NoPen);
// draw points
circle.moveCenter(savedStart);
painter->drawRect(circle);
for (int i = 1; i < sz-1; ++i) {
if (i != m_activePointIndex) {
circle.moveCenter(m_points.at(i));
painter->drawRect(circle);
}
}
circle.moveCenter(savedEnd);
painter->drawRect(circle);
if (m_activePointIndex != -1) {
painter->setBrush(invertedColor);
painter->setPen(Qt::NoPen);
circle.setWidth(1.5*SelectedPointDiameter);
circle.setHeight(1.5*SelectedPointDiameter);
circle.moveCenter(m_points.at(m_activePointIndex));
painter->drawEllipse(circle);
}
else if (m_activeSegmentIndex != -1) {
if (m_layout == Polyline) {
painter->setPen(QPen(invertedColor, _pen.widthF() + 1));
painter->setBrush(Qt::NoBrush);
QLineF segmentLine(m_points[m_activeSegmentIndex], m_points[m_activeSegmentIndex + 1]);
painter->drawLine(segmentLine);
}
}
// debug info
if (Tracer::instance()->isEnabled(QString::fromLatin1(metaObject()->className()))) {
painter->setPen(Qt::green);
painter->setBrush(Qt::NoBrush);
painter->drawPath(shape());
painter->setPen(Qt::red);
painter->drawRect(boundingRect());
// origin
painter->drawLine(-10, 0, 10, 0);
painter->drawLine(0, -10, 0, 10);
}
}
// now restore the points array
m_points[0] = savedStart;
m_points[sz - 1] = savedEnd;
}
void FindIndicator::draw(GraphicsContext& graphicsContext, const IntRect& dirtyRect)
{
for (size_t i = 0; i < m_textRects.size(); ++i) {
FloatRect textRect = m_textRects[i];
textRect.move(leftBorderThickness, topBorderThickness);
graphicsContext.save();
FloatRect outerPathRect = inflateRect(textRect, horizontalOutsetToCenterOfLightBorder, verticalOutsetToCenterOfLightBorder);
graphicsContext.setShadow(FloatSize(shadowOffsetX, shadowOffsetY), shadowBlurRadius, shadowColor(), ColorSpaceSRGB);
graphicsContext.addPath(pathWithRoundedRect(outerPathRect, cornerRadius));
graphicsContext.setFillColor(lightBorderColor(), ColorSpaceDeviceRGB);
graphicsContext.fillPath();
graphicsContext.restore();
graphicsContext.save();
FloatRect innerPathRect = inflateRect(textRect, horizontalPaddingInsideLightBorder, verticalPaddingInsideLightBorder);
graphicsContext.clip(pathWithRoundedRect(innerPathRect, cornerRadius));
RefPtr<Gradient> gradient = Gradient::create(FloatPoint(innerPathRect.x(), innerPathRect.y()), FloatPoint(innerPathRect.x(), innerPathRect.bottom()));
gradient->addColorStop(0, gradientLightColor());
gradient->addColorStop(1, gradientDarkColor());
graphicsContext.setFillGradient(gradient);
graphicsContext.fillRect(outerPathRect);
graphicsContext.restore();
graphicsContext.save();
graphicsContext.translate(FloatSize(roundf(leftBorderThickness), roundf(topBorderThickness) + m_contentImage->bounds().height()));
graphicsContext.scale(FloatSize(1, -1));
m_contentImage->paint(&graphicsContext, m_contentImage->bounds());
graphicsContext.restore();
}
}