void StreamDisplay::DrawPrimitives()
{
DrawMask( m_fTrailingPercent ); // this is the "right endcap" to the life
const float fChamberWidthInPercent = 1.0f/m_iNumChambers;
float fStripWidthInPercent = 1.0f/m_iNumStrips;
float fPercentBetweenStrips = 1.0f/m_iNumStrips;
// round down so that the chamber overflows align
if( m_iNumChambers > 10 )
fPercentBetweenStrips = Quantize( fPercentBetweenStrips-fChamberWidthInPercent/2, fChamberWidthInPercent );
if( m_iNumChambers > 3 )
fPercentBetweenStrips -= 2*fChamberWidthInPercent;
float fPercentOffset = fmodf( GAMESTATE->m_fSongBeat/4+1000, fPercentBetweenStrips );
ASSERT( fPercentOffset >= 0 && fPercentOffset <= fPercentBetweenStrips );
// "+fPercentBetweenStrips" so that the whole area is overdrawn 2x
for( float f=fPercentOffset+1+fPercentBetweenStrips; f>=0; f-=fPercentBetweenStrips )
{
DrawMask( f );
DrawStrip( f, fStripWidthInPercent );
}
// Don't leave the Zbuffer in a messy state for arrows and dancing characters
DISPLAY->ClearZBuffer();
}
void DrawPrimitives()
{
if( GAMESTATE->IsPlayerEnabled(m_PlayerNumber) )
{
DrawMask( m_fPercent ); // this is the "right endcap" to the life
const float fChamberWidthInPercent = 1.0f/NUM_CHAMBERS;
float fPercentBetweenStrips = 1.0f/NUM_STRIPS;
// round this so that the chamber overflows align
if( NUM_CHAMBERS > 10 )
fPercentBetweenStrips = froundf( fPercentBetweenStrips, fChamberWidthInPercent );
float fPercentOffset = fmodf( GAMESTATE->m_fSongBeat/4+1000, fPercentBetweenStrips );
ASSERT( fPercentOffset >= 0 && fPercentOffset <= fPercentBetweenStrips );
for( float f=fPercentOffset+1; f>=0; f-=fPercentBetweenStrips )
{
DrawMask( f );
DrawStrip( f );
}
}
m_sprFrame.Draw();
}
void wxSVGCanvasCairo::DrawMarker(const wxString& uri, wxSVGMark::Type type, wxSVGCanvasPathCairo& canvasPath,
const wxSVGMatrix& matrix, const wxCSSStyleDeclaration& style, wxSVGSVGElement& svgElem) {
wxSVGMarkerElement* markerElem = GetMarkerElement(svgElem, uri);
if (markerElem == NULL || markerElem->GetMarkerWidth().GetAnimVal() <= 0
|| markerElem->GetMarkerHeight().GetAnimVal() <= 0)
return;
vector<wxSVGMark> markPoints = canvasPath.GetMarkPoints();
for (vector<wxSVGMark>::iterator it = markPoints.begin(); it != markPoints.end(); it++) {
if (it->type != type)
continue;
wxSVGMark& markPoint = *it;
double scaleX = matrix.GetA() * style.GetStrokeWidth();
double scaleY = matrix.GetD() * style.GetStrokeWidth();
markerElem->SetOwnerSVGElement(&svgElem);
markerElem->SetViewportElement(&svgElem);
cairo_surface_t* surface = cairo_image_surface_create(
CAIRO_FORMAT_ARGB32,
lround(markerElem->GetMarkerWidth().GetAnimVal() * scaleX),
lround(markerElem->GetMarkerHeight().GetAnimVal() * scaleY));
cairo_t* cr = cairo_create(surface);
wxSVGMatrix markerMatrix;
markerMatrix = markerMatrix.ScaleNonUniform(scaleX, scaleY);
wxCSSStyleDeclaration style;
DrawMask(cr, markerElem, markerMatrix, style, svgElem);
// draw surface
cairo_save(m_cr);
double refX = markerElem->GetRefX().GetAnimVal() * style.GetStrokeWidth();
double refY = markerElem->GetRefY().GetAnimVal() * style.GetStrokeWidth();
wxSVGPoint point(markPoint.x - refX, markPoint.y - refY);
point = point.MatrixTransform(matrix);
wxSVGMatrix m;
m = m.Translate(point.GetX(), point.GetY());
if (markPoint.angle != 0) {
refX = markerElem->GetRefX().GetAnimVal() * scaleX;
refY = markerElem->GetRefY().GetAnimVal() * scaleY;
m = m.Translate(refX, refY).Rotate(markPoint.angle / M_PI * 180).Translate(-refX, -refY);
}
SetMatrix(m_cr, m);
cairo_set_source_surface(m_cr, surface, 0, 0);
cairo_paint(m_cr);
cairo_restore(m_cr);
cairo_destroy(cr);
cairo_surface_destroy(surface);
}
}
void NText::Draw(NCamera* View)
{
if (!Face)
{
return;
}
if (W<=0)
{
DrawText(View);
return;
}
glClear(GL_STENCIL_BUFFER_BIT);
glEnable(GL_STENCIL_TEST);
glStencilFunc(GL_ALWAYS,0x1,0x1);
glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
DrawMask(View);
glStencilFunc(GL_EQUAL,0x1,0x1);
glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
DrawText(View);
glDisable(GL_STENCIL_TEST);
}
CBitmap* COrnament::GetMask(void)
{
CDC *pDC = m_pContext->GetDC();
ASSERT(pDC != NULL);
// If the mask bitmap is not valid give the current state, free the
// current bitmap and build the new one.
if (MaskNeeded())
{
m_bmMask.DeleteObject();
}
// Check if we need to build a new bitmap.
if (m_bmMask.GetSafeHandle() == NULL)
{
// Create the bitmap for the mask.
CRect crMask(0, 0, Max(CurrentState()->m_czExtent.cx, 1), Max(CurrentState()->m_czExtent.cy, 1));
if (m_bmMask.CreateBitmap(crMask.Width(), crMask.Height(), 1, 1, NULL))
{
// Create a memory compatible DC and select the new bitmap into it.
CDC MaskDC;
if (MaskDC.CreateCompatibleDC(pDC))
{
CBrush cbTransparent(RGB(255,255,255));
int nContext;
if ((nContext = MaskDC.SaveDC()) != 0)
{
MaskDC.SetMapMode(MM_TEXT);
if (MaskDC.SelectObject(&m_bmMask) != NULL)
{
// Create the mask image. Pixels that should be masked out should
// be set to zero (black). Pixels that should be transparent should
// be set to one (white).
MaskDC.FillRect(&crMask, &cbTransparent);
DrawMask(&MaskDC);
ClearMaskNeeded();
}
MaskDC.RestoreDC(nContext);
}
}
}
}
m_pContext->ReleaseDC();
ASSERT(m_bmMask.GetSafeHandle() != NULL);
if (m_bmMask.GetSafeHandle() == NULL)
{
return NULL;
}
return &m_bmMask;
}
/* ---------------------------------------------------------------------------
* initializes some identifiers for a new zoom factor and redraws whole screen
*/
static void
DrawEverything (const BoxType *drawn_area)
{
int i, ngroups, side;
int component, solder;
/* This is the list of layer groups we will draw. */
int do_group[MAX_LAYER];
/* This is the reverse of the order in which we draw them. */
int drawn_groups[MAX_LAYER];
int plated, unplated;
bool paste_empty;
PCB->Data->SILKLAYER.Color = PCB->ElementColor;
PCB->Data->BACKSILKLAYER.Color = PCB->InvisibleObjectsColor;
memset (do_group, 0, sizeof (do_group));
for (ngroups = 0, i = 0; i < max_copper_layer; i++)
{
LayerType *l = LAYER_ON_STACK (i);
int group = GetLayerGroupNumberByNumber (LayerStack[i]);
if (l->On && !do_group[group])
{
do_group[group] = 1;
drawn_groups[ngroups++] = group;
}
}
component = GetLayerGroupNumberByNumber (component_silk_layer);
solder = GetLayerGroupNumberByNumber (solder_silk_layer);
/*
* first draw all 'invisible' stuff
*/
if (!TEST_FLAG (CHECKPLANESFLAG, PCB)
&& gui->set_layer ("invisible", SL (INVISIBLE, 0), 0))
{
side = SWAP_IDENT ? COMPONENT_LAYER : SOLDER_LAYER;
if (PCB->ElementOn)
{
r_search (PCB->Data->element_tree, drawn_area, NULL, element_callback, &side);
r_search (PCB->Data->name_tree[NAME_INDEX (PCB)], drawn_area, NULL, name_callback, &side);
DrawLayer (&(PCB->Data->Layer[max_copper_layer + side]), drawn_area);
}
r_search (PCB->Data->pad_tree, drawn_area, NULL, pad_callback, &side);
gui->end_layer ();
}
/* draw all layers in layerstack order */
for (i = ngroups - 1; i >= 0; i--)
{
int group = drawn_groups[i];
if (gui->set_layer (0, group, 0))
{
DrawLayerGroup (group, drawn_area);
gui->end_layer ();
}
}
if (TEST_FLAG (CHECKPLANESFLAG, PCB) && gui->gui)
return;
/* Draw pins, pads, vias below silk */
if (gui->gui)
DrawPPV (SWAP_IDENT ? solder : component, drawn_area);
else
{
CountHoles (&plated, &unplated, drawn_area);
if (plated && gui->set_layer ("plated-drill", SL (PDRILL, 0), 0))
{
DrawHoles (true, false, drawn_area);
gui->end_layer ();
}
if (unplated && gui->set_layer ("unplated-drill", SL (UDRILL, 0), 0))
{
DrawHoles (false, true, drawn_area);
gui->end_layer ();
}
}
/* Draw the solder mask if turned on */
if (gui->set_layer ("componentmask", SL (MASK, TOP), 0))
{
DrawMask (COMPONENT_LAYER, drawn_area);
gui->end_layer ();
}
if (gui->set_layer ("soldermask", SL (MASK, BOTTOM), 0))
{
DrawMask (SOLDER_LAYER, drawn_area);
gui->end_layer ();
}
if (gui->set_layer ("topsilk", SL (SILK, TOP), 0))
{
DrawSilk (COMPONENT_LAYER, drawn_area);
gui->end_layer ();
}
if (gui->set_layer ("bottomsilk", SL (SILK, BOTTOM), 0))
{
DrawSilk (SOLDER_LAYER, drawn_area);
gui->end_layer ();
}
if (gui->gui)
{
/* Draw element Marks */
if (PCB->PinOn)
r_search (PCB->Data->element_tree, drawn_area, NULL, EMark_callback,
NULL);
/* Draw rat lines on top */
if (gui->set_layer ("rats", SL (RATS, 0), 0))
{
DrawRats(drawn_area);
gui->end_layer ();
}
}
paste_empty = IsPasteEmpty (COMPONENT_LAYER);
if (gui->set_layer ("toppaste", SL (PASTE, TOP), paste_empty))
{
DrawPaste (COMPONENT_LAYER, drawn_area);
gui->end_layer ();
}
paste_empty = IsPasteEmpty (SOLDER_LAYER);
if (gui->set_layer ("bottompaste", SL (PASTE, BOTTOM), paste_empty))
{
DrawPaste (SOLDER_LAYER, drawn_area);
gui->end_layer ();
}
if (gui->set_layer ("topassembly", SL (ASSY, TOP), 0))
{
PrintAssembly (COMPONENT_LAYER, drawn_area);
gui->end_layer ();
}
if (gui->set_layer ("bottomassembly", SL (ASSY, BOTTOM), 0))
{
PrintAssembly (SOLDER_LAYER, drawn_area);
gui->end_layer ();
}
if (gui->set_layer ("fab", SL (FAB, 0), 0))
{
PrintFab (Output.fgGC);
gui->end_layer ();
}
}
canvas->saveLayer(rec);
canvas->drawColor(SK_ColorBLUE);
canvas->restore();
}
}
private:
static constexpr int kSize = 400;
SkString fName;
sk_sp<SkImage> fClip;
};
DEF_BENCH(return new ClipMaskBench("a8", [](int size) -> sk_sp<SkImage> {
sk_sp<SkSurface> surface = SkSurface::MakeRaster(SkImageInfo::MakeA8(size, size));
DrawMask(surface->getCanvas());
return surface->makeImageSnapshot();
});)
DEF_BENCH(return new ClipMaskBench("8888", [](int size) -> sk_sp<SkImage> {
sk_sp<SkSurface> surface = SkSurface::MakeRasterN32Premul(size, size);
DrawMask(surface->getCanvas());
return surface->makeImageSnapshot();
});)
DEF_BENCH(return new ClipMaskBench("picture", [](int size) -> sk_sp<SkImage> {
SkPictureRecorder recorder;
DrawMask(recorder.beginRecording(size, size));
return SkImage::MakeFromPicture(recorder.finishRecordingAsPicture(), SkISize::Make(size, size),
nullptr, nullptr, SkImage::BitDepth::kU8,
SkColorSpace::MakeSRGB());
void pawsProgressBar::Draw()
{
ClipToParent(false);
int alpha = 255;
int Time = csGetTicks();
int primary_r;
int primary_g;
int primary_b;
if(parent && !parent->GetBackground().IsEmpty() && parent->isFadeEnabled() && parent->GetMaxAlpha() != parent->GetMinAlpha())
{
alpha = (int) (255 - (parent->GetMinAlpha() + (parent->GetMaxAlpha()-parent->GetMinAlpha()) * parent->GetFadeVal() * 0.010));
}
DrawBackground();
if( flashLevel > 0 )
{
if( ( (flashLow && percent<flashLevel) || (!flashLow && percent>flashLevel) ) )
{
if( flashLastTime+flashRate <= Time )
{
On=!On;
flashLastTime = Time;
}
}
else
{
On=true;
}
}
if( warnLevel > 0 && ( (warnLow && percent < warnLevel) || (!warnLow && percent >warnLevel) ) )
{
if( dangerLevel > 0 && ( (dangerLow && percent < dangerLevel) || (!dangerLow && percent >dangerLevel) ) )
{
primary_r = danger_r;
primary_g = danger_g;
primary_b = danger_b;
}
else
{
primary_r = warn_r;
primary_g = warn_g;
primary_b = warn_b;
}
}
else
{
primary_r = start_r;
primary_g = start_g;
primary_b = start_b;
}
if( On )
{
DrawProgressBar(screenFrame, PawsManager::GetSingleton().GetGraphics3D(), percent,
primary_r, primary_g, primary_b,
diff_r, diff_g, diff_b, alpha);
}
else
{
DrawProgressBar(screenFrame, PawsManager::GetSingleton().GetGraphics3D(), percent,
flash_r, flash_g, flash_b,
flash_r, flash_g, flash_b, alpha);
}
DrawChildren();
DrawMask();
}
void wxSVGCanvasCairo::DrawCanvasImage(wxSVGCanvasImage& canvasImage, cairo_surface_t* cairoSurface,
wxSVGMatrix& matrix, const wxCSSStyleDeclaration& style, wxSVGSVGElement& svgElem) {
if (cairoSurface == NULL)
return;
cairo_save(m_cr);
// ClipPath
if (style.GetClipPath().GetCSSPrimitiveType() == wxCSS_URI && style.GetClipPath().GetStringValue().length() > 1) {
wxString clipPathId = style.GetClipPath().GetStringValue().substr(1);
wxSVGClipPathElement* clipPathElem = (wxSVGClipPathElement*) svgElem.GetElementById(clipPathId);
if (clipPathElem && clipPathElem->GetDtd() == wxSVG_CLIPPATH_ELEMENT) {
clipPathElem->SetOwnerSVGElement(&svgElem);
clipPathElem->SetViewportElement(&svgElem);
wxSVGMatrix clipMatrix(matrix);
clipPathElem->UpdateMatrix(clipMatrix);
SetClipPath(clipPathElem, clipMatrix);
}
}
SetMatrix(m_cr, matrix);
// scale context
double x = canvasImage.m_x;
double y = canvasImage.m_y;
double scaleX = canvasImage.m_width / canvasImage.m_image.GetWidth();
double scaleY = canvasImage.m_height / canvasImage.m_image.GetHeight();
wxSVG_PRESERVEASPECTRATIO align = canvasImage.GetPreserveAspectRatio().GetAlign();
bool alignX = false;
if (align > wxSVG_PRESERVEASPECTRATIO_NONE) {
scaleY = canvasImage.m_height / canvasImage.GetDefaultHeight();
if (canvasImage.GetPreserveAspectRatio().GetMeetOrSlice() != wxSVG_MEETORSLICE_SLICE) {
alignX = scaleX > scaleY;
} else {
cairo_rectangle(m_cr, x, y, canvasImage.m_width, canvasImage.m_height);
cairo_clip(m_cr);
alignX = scaleX < scaleY;
}
if (alignX) {
scaleX = scaleY;
if (align == wxSVG_PRESERVEASPECTRATIO_XMIDYMIN
|| align == wxSVG_PRESERVEASPECTRATIO_XMIDYMID
|| align == wxSVG_PRESERVEASPECTRATIO_XMIDYMAX)
x += (canvasImage.m_width - canvasImage.GetDefaultWidth() * scaleX) / 2;
else if (align == wxSVG_PRESERVEASPECTRATIO_XMAXYMIN
|| align == wxSVG_PRESERVEASPECTRATIO_XMAXYMID
|| align == wxSVG_PRESERVEASPECTRATIO_XMAXYMAX)
x += canvasImage.m_width - canvasImage.GetDefaultWidth() * scaleX;
} else {
scaleY = scaleX;
if (align == wxSVG_PRESERVEASPECTRATIO_XMINYMID
|| align == wxSVG_PRESERVEASPECTRATIO_XMIDYMID
|| align == wxSVG_PRESERVEASPECTRATIO_XMAXYMID)
y += (canvasImage.m_height - canvasImage.GetDefaultHeight() * scaleY) / 2;
else if (align == wxSVG_PRESERVEASPECTRATIO_XMINYMAX
|| align == wxSVG_PRESERVEASPECTRATIO_XMIDYMAX
|| align == wxSVG_PRESERVEASPECTRATIO_XMAXYMAX)
y += canvasImage.m_height - canvasImage.GetDefaultHeight() * scaleY;
}
scaleY = scaleY * canvasImage.GetDefaultHeight() / canvasImage.m_image.GetHeight();
}
cairo_translate(m_cr, x, y);
cairo_scale(m_cr, scaleX, scaleY);
// prepare to draw the image
cairo_set_source_surface(m_cr, cairoSurface, 0, 0);
// use the original size here since the context is scaled already...
cairo_rectangle(m_cr, 0, 0, canvasImage.m_image.GetWidth(), canvasImage.m_image.GetHeight());
// paint
if (style.GetMask().GetCSSPrimitiveType() == wxCSS_URI && style.GetMask().GetStringValue().length() > 1) {
wxString maskId = style.GetMask().GetStringValue().substr(1);
wxSVGMaskElement* maskElem = (wxSVGMaskElement*) svgElem.GetElementById(maskId);
if (maskElem && maskElem->GetDtd() == wxSVG_MASK_ELEMENT) {
maskElem->SetOwnerSVGElement(&svgElem);
maskElem->SetViewportElement(&svgElem);
cairo_surface_t* surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32,
svgElem.GetWidth().GetAnimVal()/scaleX, svgElem.GetHeight().GetAnimVal()/scaleY);
cairo_t* cr = cairo_create(surface);
wxSVGMatrix maskMatrix;
maskMatrix = maskMatrix.Translate(x, y).ScaleNonUniform(scaleX, scaleY).Inverse();
DrawMask(cr, maskElem, maskMatrix, style, svgElem);
cairo_mask_surface(m_cr, surface, 0, 0);
cairo_destroy(cr);
cairo_surface_destroy(surface);
}
} else {
cairo_paint_with_alpha(m_cr, style.GetOpacity());
}
cairo_new_path(m_cr);
// clean up
cairo_restore(m_cr);
}
void wxSVGCanvasCairo::DrawMask(cairo_t* cr, wxSVGElement* maskElem, const wxSVGMatrix& matrix,
const wxCSSStyleDeclaration& style, wxSVGSVGElement& svgElem) {
SetMatrix(cr, matrix);
wxSVGElement* elem = (wxSVGElement*) (maskElem->GetFirstChild());
while (elem != NULL) {
elem->SetOwnerSVGElement(maskElem->GetOwnerSVGElement());
elem->SetViewportElement(maskElem->GetViewportElement());
wxSVGDocument* doc = (wxSVGDocument*) elem->GetOwnerDocument();
wxSVGCanvasItem* canvasItem = NULL;
wxCSSStyleDeclaration resStyle = style;
switch (elem->GetDtd()) {
case wxSVG_G_ELEMENT: {
wxSVGGElement* gElement = (wxSVGGElement*) elem;
if (gElement->GetVisibility() == wxCSS_VALUE_HIDDEN)
break;
resStyle.Add(((wxSVGGElement*) elem)->GetStyle());
DrawMask(cr, elem, matrix, resStyle, svgElem);
break;
}
case wxSVG_LINE_ELEMENT: {
wxSVGLineElement* element = (wxSVGLineElement*) elem;
if (element->GetVisibility() == wxCSS_VALUE_HIDDEN)
break;
canvasItem = doc->GetCanvas()->CreateItem(element);
resStyle.Add(element->GetStyle());
resStyle.Add(element->GetAnimStyle());
break;
}
case wxSVG_POLYLINE_ELEMENT: {
wxSVGPolylineElement* element = (wxSVGPolylineElement*) elem;
if (element->GetVisibility() == wxCSS_VALUE_HIDDEN)
break;
canvasItem = doc->GetCanvas()->CreateItem(element);
resStyle.Add(element->GetStyle());
resStyle.Add(element->GetAnimStyle());
break;
}
case wxSVG_POLYGON_ELEMENT: {
wxSVGPolygonElement* element = (wxSVGPolygonElement*) elem;
if (element->GetVisibility() == wxCSS_VALUE_HIDDEN)
break;
canvasItem = doc->GetCanvas()->CreateItem(element);
resStyle.Add(element->GetStyle());
resStyle.Add(element->GetAnimStyle());
break;
}
case wxSVG_RECT_ELEMENT: {
wxSVGRectElement* element = (wxSVGRectElement*) elem;
if (element->GetVisibility() == wxCSS_VALUE_HIDDEN)
break;
canvasItem = doc->GetCanvas()->CreateItem(element);
resStyle.Add(element->GetStyle());
resStyle.Add(element->GetAnimStyle());
break;
}
case wxSVG_CIRCLE_ELEMENT: {
wxSVGCircleElement* element = (wxSVGCircleElement*) elem;
if (element->GetVisibility() == wxCSS_VALUE_HIDDEN)
break;
canvasItem = doc->GetCanvas()->CreateItem(element);
resStyle.Add(element->GetStyle());
resStyle.Add(element->GetAnimStyle());
break;
}
case wxSVG_ELLIPSE_ELEMENT: {
wxSVGEllipseElement* element = (wxSVGEllipseElement*) elem;
if (element->GetVisibility() == wxCSS_VALUE_HIDDEN)
break;
canvasItem = doc->GetCanvas()->CreateItem(element);
resStyle.Add(element->GetStyle());
resStyle.Add(element->GetAnimStyle());
break;
}
case wxSVG_PATH_ELEMENT: {
wxSVGPathElement* element = (wxSVGPathElement*) elem;
if (element->GetVisibility() == wxCSS_VALUE_HIDDEN)
break;
canvasItem = doc->GetCanvas()->CreateItem(element);
resStyle.Add(element->GetStyle());
resStyle.Add(element->GetAnimStyle());
break;
}
case wxSVG_USE_ELEMENT: {
wxSVGUseElement* element = (wxSVGUseElement*) elem;
if (element->GetVisibility() == wxCSS_VALUE_HIDDEN)
break;
resStyle.Add(element->GetStyle());
resStyle.Add(element->GetAnimStyle());
// get ref element
wxString href = element->GetHref();
if (href.length() == 0 || href.GetChar(0) != wxT('#'))
break;
href.Remove(0, 1);
wxSVGElement* refElem = (wxSVGElement*) maskElem->GetOwnerSVGElement()->GetElementById(href);
if (!refElem)
break;
// create shadow tree
wxSVGGElement* gElem = new wxSVGGElement();
gElem->SetOwnerDocument(elem->GetOwnerDocument());
gElem->SetOwnerSVGElement(maskElem->GetOwnerSVGElement());
gElem->SetViewportElement(maskElem->GetViewportElement());
gElem->SetStyle(element->GetStyle());
if (element->GetX().GetAnimVal().GetUnitType() != wxSVG_LENGTHTYPE_UNKNOWN)
gElem->Translate(element->GetX().GetAnimVal(), element->GetY().GetAnimVal());
if (refElem->GetDtd() == wxSVG_SYMBOL_ELEMENT || refElem->GetDtd() == wxSVG_SVG_ELEMENT) {
wxSVGSVGElement* svgElem;
if (refElem->GetDtd() == wxSVG_SVG_ELEMENT)
svgElem = (wxSVGSVGElement*) refElem->CloneNode();
else {
svgElem = new wxSVGSVGElement();
wxSvgXmlElement* child = refElem->GetChildren();
while (child) {
svgElem->AddChild(child->CloneNode());
child = child->GetNext();
}
svgElem->SetViewBox(((wxSVGSymbolElement*) refElem)->GetViewBox());
svgElem->SetPreserveAspectRatio(((wxSVGSymbolElement*) refElem)->GetPreserveAspectRatio());
}
if (element->GetWidth().GetAnimVal().GetUnitType() != wxSVG_LENGTHTYPE_UNKNOWN)
svgElem->SetWidth(element->GetWidth().GetAnimVal());
if (element->GetHeight().GetAnimVal().GetUnitType() != wxSVG_LENGTHTYPE_UNKNOWN)
svgElem->SetHeight(element->GetHeight().GetAnimVal());
gElem->AddChild(svgElem);
} else
gElem->AddChild(refElem->CloneNode());
// render
DrawMask(cr, gElem, matrix, resStyle, svgElem);
// delete shadow tree
delete gElem;
break;
}
default:
break;
}
if (canvasItem != NULL) {
DrawPath(cr, ((wxSVGCanvasPathCairo&) *canvasItem), matrix, resStyle, svgElem);
delete canvasItem;
}
elem = (wxSVGElement*) elem->GetNextSibling();
}
}
void wxSVGCanvasCairo::SetPaint(cairo_t* cr, const wxSVGPaint& paint, float opacity, wxSVGCanvasPathCairo& canvasPath,
wxSVGSVGElement& svgElem, const wxSVGMatrix& matrix) {
if (paint.GetPaintType() >= wxSVG_PAINTTYPE_URI_NONE && paint.GetPaintType() <= wxSVG_PAINTTYPE_URI) {
wxSVGGradientElement* gradElem = GetGradientElement(svgElem, paint.GetUri());
if (gradElem != NULL) {
if (m_pattern != NULL) {
cairo_pattern_destroy(m_pattern);
m_pattern = NULL;
}
switch (gradElem->GetDtd()) {
case wxSVG_LINEARGRADIENT_ELEMENT: {
wxSVGPoint p1, p2;
GetLinearGradientVector(p1, p2, (wxSVGLinearGradientElement&) *gradElem, canvasPath);
m_pattern = cairo_pattern_create_linear(p1.GetX(), p1.GetY(), p2.GetX(), p2.GetY());
break;
}
case wxSVG_RADIALGRADIENT_ELEMENT: {
wxSVGRadialGradientElement* radialGradElem = (wxSVGRadialGradientElement*) gradElem;
double r = radialGradElem->GetQualifiedR();
double cx = radialGradElem->GetQualifiedCx();
double cy = radialGradElem->GetQualifiedCy();
double fx = radialGradElem->GetQualifiedFx();
double fy = radialGradElem->GetQualifiedFy();
if (gradElem->GetGradientUnits().GetAnimVal() == wxSVG_UNIT_TYPE_UNKNOWN
|| gradElem->GetGradientUnits().GetAnimVal() == wxSVG_UNIT_TYPE_OBJECTBOUNDINGBOX) {
wxSVGRect bbox = canvasPath.GetBBox();
r = r * sqrt(bbox.GetWidth() * bbox.GetWidth() + bbox.GetHeight() * bbox.GetHeight());
cx = bbox.GetX() + cx * bbox.GetWidth();
cy = bbox.GetY() + cy * bbox.GetHeight();
fx = bbox.GetX() + fx * bbox.GetWidth();
fy = bbox.GetY() + fy * bbox.GetHeight();
}
m_pattern = cairo_pattern_create_radial(fx, fy, 0.0, cx, cy, r);
const wxSVGTransformList& transforms = gradElem->GetGradientTransform().GetAnimVal();
if (transforms.GetCount() > 0) {
wxSVGMatrix patMatrix;
for (unsigned int i = 0; i < transforms.GetCount(); i++)
patMatrix = patMatrix.Multiply(transforms[i].GetMatrix());
patMatrix = patMatrix.Inverse();
cairo_matrix_t mat;
cairo_matrix_init(&mat, patMatrix.GetA(), patMatrix.GetB(), patMatrix.GetC(), patMatrix.GetD(), patMatrix.GetE(), patMatrix.GetF());
cairo_pattern_set_matrix(m_pattern, &mat);
}
break;
}
default:
break;
}
if (m_pattern != NULL) {
int nstops = GetGradientStops(svgElem, gradElem, opacity);
if (nstops) {
cairo_set_source(cr, m_pattern);
} else {
cairo_pattern_destroy(m_pattern);
m_pattern = NULL;
}
}
}
wxSVGPatternElement* patternElem = GetPatternElement(svgElem, paint.GetUri());
if (patternElem != NULL && patternElem->GetWidth().GetAnimVal() > 0
&& patternElem->GetHeight().GetAnimVal() > 0) {
if (m_pattern != NULL) {
cairo_pattern_destroy(m_pattern);
m_pattern = NULL;
}
double scaleX = matrix.GetA();
scaleX = lround(patternElem->GetWidth().GetAnimVal()*scaleX) / patternElem->GetWidth().GetAnimVal();
double scaleY = matrix.GetD();
scaleY = lround(patternElem->GetHeight().GetAnimVal()*scaleY) / patternElem->GetHeight().GetAnimVal();
patternElem->SetOwnerSVGElement(&svgElem);
patternElem->SetViewportElement(&svgElem);
cairo_surface_t* surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32,
lround(patternElem->GetWidth().GetAnimVal()*scaleX),
lround(patternElem->GetHeight().GetAnimVal()*scaleY));
cairo_t* cr = cairo_create(surface);
wxSVGMatrix patMatrix;
patMatrix = patMatrix.ScaleNonUniform(scaleX, scaleY);
wxCSSStyleDeclaration style;
DrawMask(cr, patternElem, patMatrix, style, svgElem);
m_pattern = cairo_pattern_create_for_surface(surface);
if (patternElem->GetX().GetAnimVal() > 0 || patternElem->GetY().GetAnimVal() > 0) {
patMatrix = patMatrix.Translate(patternElem->GetX().GetAnimVal(), patternElem->GetY().GetAnimVal());
}
if (patternElem->GetPatternTransform().GetAnimVal().size()) {
const wxSVGTransformList& transforms = patternElem->GetPatternTransform().GetAnimVal();
for (unsigned int i = 0; i < transforms.Count(); i++) {
patMatrix = patMatrix.Multiply(transforms[i].GetMatrix().Inverse());
}
}
cairo_matrix_t mat;
cairo_matrix_init(&mat, patMatrix.GetA(), patMatrix.GetB(), patMatrix.GetC(), patMatrix.GetD(), patMatrix.GetE(), patMatrix.GetF());
cairo_pattern_set_matrix(m_pattern, &mat);
cairo_set_source(m_cr, m_pattern);
cairo_pattern_set_extend(m_pattern, CAIRO_EXTEND_REPEAT);
cairo_destroy(cr);
cairo_surface_destroy(surface);
}
} else {
wxRGBColor color = paint.GetRGBColor();
cairo_set_source_rgba(cr, color.Red() / 255.0, color.Green() / 255.0, color.Blue() / 255.0, opacity);
}
}
