DISTRHO
/
DPF
mirror of https://github.com/DISTRHO/DPF
1
0
Fork 0
Code Releases 0 Activity
Browse Source

Don't crash if NanoVG context is invalid; Always valid UI size

gh-pages
falkTX 10 years ago
parent
0b834cfc8c
commit
f1f5853c92
2 changed files with 170 additions and 41 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +162
    -38
      dgl/src/NanoVG.cpp
  2. +8
    -3
      distrho/src/DistrhoUIInternal.hpp

+ 162
- 38
dgl/src/NanoVG.cpp View File

@@ -106,6 +106,8 @@ Size<int> NanoImage::getSize() const

void NanoImage::updateImage(const uchar* data)
{
DISTRHO_SAFE_ASSERT_RETURN(data != nullptr,);

if (fContext != nullptr && fImageId != 0)
nvgUpdateImage(fContext, fImageId, data);
}
@@ -127,21 +129,25 @@ NanoVG::NanoVG(int textAtlasWidth, int textAtlasHeight)

NanoVG::~NanoVG()
{
if (fContext == nullptr)
return;

nvgDeleteGL(fContext);
if (fContext != nullptr)
nvgDeleteGL(fContext);
}

// -----------------------------------------------------------------------

void NanoVG::beginFrame(int width, int height, float scaleFactor, Alpha alpha)
{
if (fContext == nullptr) return;
DISTRHO_SAFE_ASSERT_RETURN(width > 0,);
DISTRHO_SAFE_ASSERT_RETURN(height > 0,);
DISTRHO_SAFE_ASSERT_RETURN(scaleFactor > 0.0f,);

nvgBeginFrame(fContext, width, height, scaleFactor, static_cast<NVGalpha>(alpha));
}

void NanoVG::beginFrame(Widget* widget)
{
if (fContext == nullptr) return;
DISTRHO_SAFE_ASSERT_RETURN(widget != nullptr,);

Window& window(widget->getParentWindow());
@@ -150,7 +156,8 @@ void NanoVG::beginFrame(Widget* widget)

void NanoVG::endFrame()
{
nvgEndFrame(fContext);
if (fContext != nullptr)
nvgEndFrame(fContext);
}

// -----------------------------------------------------------------------
@@ -196,17 +203,20 @@ NanoVG::Color NanoVG::HSLA(float h, float s, float l, uchar a)

void NanoVG::save()
{
nvgSave(fContext);
if (fContext != nullptr)
nvgSave(fContext);
}

void NanoVG::restore()
{
nvgRestore(fContext);
if (fContext != nullptr)
nvgRestore(fContext);
}

void NanoVG::reset()
{
nvgReset(fContext);
if (fContext != nullptr)
nvgReset(fContext);
}

// -----------------------------------------------------------------------
@@ -214,42 +224,54 @@ void NanoVG::reset()

void NanoVG::strokeColor(const Color& color)
{
nvgStrokeColor(fContext, color);
if (fContext != nullptr)
nvgStrokeColor(fContext, color);
}

void NanoVG::strokePaint(const Paint& paint)
{
nvgStrokePaint(fContext, paint);
if (fContext != nullptr)
nvgStrokePaint(fContext, paint);
}

void NanoVG::fillColor(const Color& color)
{
nvgFillColor(fContext, color);
if (fContext != nullptr)
nvgFillColor(fContext, color);
}

void NanoVG::fillPaint(const Paint& paint)
{
nvgFillPaint(fContext, paint);
if (fContext != nullptr)
nvgFillPaint(fContext, paint);
}

void NanoVG::miterLimit(float limit)
{
if (fContext == nullptr) return;
DISTRHO_SAFE_ASSERT_RETURN(limit > 0.0f,);

nvgMiterLimit(fContext, limit);
}

void NanoVG::strokeWidth(float size)
{
if (fContext == nullptr) return;
DISTRHO_SAFE_ASSERT_RETURN(size > 0.0f,);

nvgStrokeWidth(fContext, size);
}

void NanoVG::lineCap(NanoVG::LineCap cap)
{
nvgLineCap(fContext, cap);
if (fContext != nullptr)
nvgLineCap(fContext, cap);
}

void NanoVG::lineJoin(NanoVG::LineCap join)
{
nvgLineJoin(fContext, join);
if (fContext != nullptr)
nvgLineJoin(fContext, join);
}

// -----------------------------------------------------------------------
@@ -257,42 +279,59 @@ void NanoVG::lineJoin(NanoVG::LineCap join)

void NanoVG::resetTransform()
{
nvgResetTransform(fContext);
if (fContext != nullptr)
nvgResetTransform(fContext);
}

void NanoVG::transform(float a, float b, float c, float d, float e, float f)
{
nvgTransform(fContext, a, b, c, d, e, f);
if (fContext != nullptr)
nvgTransform(fContext, a, b, c, d, e, f);
}

void NanoVG::translate(float x, float y)
{
nvgTranslate(fContext, x, y);
if (fContext != nullptr)
nvgTranslate(fContext, x, y);
}

void NanoVG::rotate(float angle)
{
if (fContext == nullptr) return;
DISTRHO_SAFE_ASSERT_RETURN(angle > 0.0f,);

nvgRotate(fContext, angle);
}

void NanoVG::skewX(float angle)
{
if (fContext == nullptr) return;
DISTRHO_SAFE_ASSERT_RETURN(angle > 0.0f,);

nvgSkewX(fContext, angle);
}

void NanoVG::skewY(float angle)
{
if (fContext == nullptr) return;
DISTRHO_SAFE_ASSERT_RETURN(angle > 0.0f,);

nvgSkewY(fContext, angle);
}

void NanoVG::scale(float x, float y)
{
if (fContext == nullptr) return;
DISTRHO_SAFE_ASSERT_RETURN(x > 0.0f,);
DISTRHO_SAFE_ASSERT_RETURN(y > 0.0f,);

nvgScale(fContext, x, y);
}

void NanoVG::currentTransform(float xform[6])
{
nvgCurrentTransform(fContext, xform);
if (fContext != nullptr)
nvgCurrentTransform(fContext, xform);
}

void NanoVG::transformIdentity(float dst[6])
@@ -360,22 +399,37 @@ float NanoVG::radToDeg(float rad)

NanoImage* NanoVG::createImage(const char* filename)
{
if (fContext == nullptr) return nullptr;
DISTRHO_SAFE_ASSERT_RETURN(filename != nullptr && filename[0] != '\0', nullptr);

if (const int imageId = nvgCreateImage(fContext, filename))
return new NanoImage(fContext, imageId);

return nullptr;
}

NanoImage* NanoVG::createImageMem(uchar* data, int ndata)
{
if (fContext == nullptr) return nullptr;
DISTRHO_SAFE_ASSERT_RETURN(data != nullptr, nullptr);
DISTRHO_SAFE_ASSERT_RETURN(ndata > 0, nullptr);

if (const int imageId = nvgCreateImageMem(fContext, data, ndata))
return new NanoImage(fContext, imageId);

return nullptr;
}

NanoImage* NanoVG::createImageRGBA(int w, int h, const uchar* data)
{
if (fContext == nullptr) return nullptr;
DISTRHO_SAFE_ASSERT_RETURN(w > 0, nullptr);
DISTRHO_SAFE_ASSERT_RETURN(h > 0, nullptr);
DISTRHO_SAFE_ASSERT_RETURN(data != nullptr, nullptr);

if (const int imageId = nvgCreateImageRGBA(fContext, w, h, data))
return new NanoImage(fContext, imageId);

return nullptr;
}

@@ -384,22 +438,27 @@ NanoImage* NanoVG::createImageRGBA(int w, int h, const uchar* data)

NanoVG::Paint NanoVG::linearGradient(float sx, float sy, float ex, float ey, const NanoVG::Color& icol, const NanoVG::Color& ocol)
{
if (fContext == nullptr) return Paint();
return nvgLinearGradient(fContext, sx, sy, ex, ey, icol, ocol);
}

NanoVG::Paint NanoVG::boxGradient(float x, float y, float w, float h, float r, float f, const NanoVG::Color& icol, const NanoVG::Color& ocol)
{
if (fContext == nullptr) return Paint();
return nvgBoxGradient(fContext, x, y, w, h, r, f, icol, ocol);
}

NanoVG::Paint NanoVG::radialGradient(float cx, float cy, float inr, float outr, const NanoVG::Color& icol, const NanoVG::Color& ocol)
{
if (fContext == nullptr) return Paint();
return nvgRadialGradient(fContext, cx, cy, inr, outr, icol, ocol);
}

NanoVG::Paint NanoVG::imagePattern(float ox, float oy, float ex, float ey, float angle, const NanoImage* image, NanoVG::PatternRepeat repeat)
{
if (fContext == nullptr) return Paint();
DISTRHO_SAFE_ASSERT_RETURN(image != nullptr, Paint());

return nvgImagePattern(fContext, ox, oy, ex, ey, angle, image->fImageId, repeat);
}

@@ -408,12 +467,14 @@ NanoVG::Paint NanoVG::imagePattern(float ox, float oy, float ex, float ey, float

void NanoVG::scissor(float x, float y, float w, float h)
{
nvgScissor(fContext, x, y, w, h);
if (fContext != nullptr)
nvgScissor(fContext, x, y, w, h);
}

void NanoVG::resetScissor()
{
nvgResetScissor(fContext);
if (fContext != nullptr)
nvgResetScissor(fContext);
}

// -----------------------------------------------------------------------
@@ -421,72 +482,86 @@ void NanoVG::resetScissor()

void NanoVG::beginPath()
{
nvgBeginPath(fContext);
if (fContext != nullptr)
nvgBeginPath(fContext);
}

void NanoVG::moveTo(float x, float y)
{
nvgMoveTo(fContext, x, y);
if (fContext != nullptr)
nvgMoveTo(fContext, x, y);
}

void NanoVG::lineTo(float x, float y)
{
nvgLineTo(fContext, x, y);
if (fContext != nullptr)
nvgLineTo(fContext, x, y);
}

void NanoVG::bezierTo(float c1x, float c1y, float c2x, float c2y, float x, float y)
{
nvgBezierTo(fContext, c1x, c1y, c2x, c2y, x, y);
if (fContext != nullptr)
nvgBezierTo(fContext, c1x, c1y, c2x, c2y, x, y);
}

void NanoVG::arcTo(float x1, float y1, float x2, float y2, float radius)
{
nvgArcTo(fContext, x1, y1, x2, y2, radius);
if (fContext != nullptr)
nvgArcTo(fContext, x1, y1, x2, y2, radius);
}

void NanoVG::closePath()
{
nvgClosePath(fContext);
if (fContext != nullptr)
nvgClosePath(fContext);
}

void NanoVG::pathWinding(NanoVG::Winding dir)
{
nvgPathWinding(fContext, dir);
if (fContext != nullptr)
nvgPathWinding(fContext, dir);
}

void NanoVG::arc(float cx, float cy, float r, float a0, float a1, NanoVG::Winding dir)
{
nvgArc(fContext, cx, cy, r, a0, a1, dir);
if (fContext != nullptr)
nvgArc(fContext, cx, cy, r, a0, a1, dir);
}

void NanoVG::rect(float x, float y, float w, float h)
{
nvgRect(fContext, x, y, w, h);
if (fContext != nullptr)
nvgRect(fContext, x, y, w, h);
}

void NanoVG::roundedRect(float x, float y, float w, float h, float r)
{
nvgRoundedRect(fContext, x, y, w, h, r);
if (fContext != nullptr)
nvgRoundedRect(fContext, x, y, w, h, r);
}

void NanoVG::ellipse(float cx, float cy, float rx, float ry)
{
nvgEllipse(fContext, cx, cy, rx, ry);
if (fContext != nullptr)
nvgEllipse(fContext, cx, cy, rx, ry);
}

void NanoVG::circle(float cx, float cy, float r)
{
nvgCircle(fContext, cx, cy, r);
if (fContext != nullptr)
nvgCircle(fContext, cx, cy, r);
}

void NanoVG::fill()
{
nvgFill(fContext);
if (fContext != nullptr)
nvgFill(fContext);
}

void NanoVG::stroke()
{
nvgStroke(fContext);
if (fContext != nullptr)
nvgStroke(fContext);
}

// -----------------------------------------------------------------------
@@ -494,71 +569,111 @@ void NanoVG::stroke()

NanoVG::FontId NanoVG::createFont(const char* name, const char* filename)
{
if (fContext == nullptr) return -1;
DISTRHO_SAFE_ASSERT_RETURN(name != nullptr && name[0] != '\0', -1);
DISTRHO_SAFE_ASSERT_RETURN(filename != nullptr && filename[0] != '\0', -1);

return nvgCreateFont(fContext, name, filename);
}

NanoVG::FontId NanoVG::createFontMem(const char* name, uchar* data, int ndata, bool freeData)
{
if (fContext == nullptr) return -1;
DISTRHO_SAFE_ASSERT_RETURN(name != nullptr && name[0] != '\0', -1);
DISTRHO_SAFE_ASSERT_RETURN(data != nullptr, -1);

return nvgCreateFontMem(fContext, name, data, ndata, freeData);
}

NanoVG::FontId NanoVG::findFont(const char* name)
{
if (fContext == nullptr) return -1;
DISTRHO_SAFE_ASSERT_RETURN(name != nullptr && name[0] != '\0', -1);

return nvgFindFont(fContext, name);
}

void NanoVG::fontSize(float size)
{
if (fContext == nullptr) return;
DISTRHO_SAFE_ASSERT_RETURN(size > 0.0f,);

nvgFontSize(fContext, size);
}

void NanoVG::fontBlur(float blur)
{
if (fContext == nullptr) return;
DISTRHO_SAFE_ASSERT_RETURN(blur >= 0.0f,);

nvgFontBlur(fContext, blur);
}

void NanoVG::textLetterSpacing(float spacing)
{
if (fContext == nullptr) return;
DISTRHO_SAFE_ASSERT_RETURN(spacing >= 0.0f,);

nvgTextLetterSpacing(fContext, spacing);
}

void NanoVG::textLineHeight(float lineHeight)
{
if (fContext == nullptr) return;
DISTRHO_SAFE_ASSERT_RETURN(lineHeight > 0.0f,);

nvgTextLineHeight(fContext, lineHeight);
}

void NanoVG::textAlign(NanoVG::Align align)
{
nvgTextAlign(fContext, align);
if (fContext != nullptr)
nvgTextAlign(fContext, align);
}

void NanoVG::textAlign(int align)
{
nvgTextAlign(fContext, align);
if (fContext != nullptr)
nvgTextAlign(fContext, align);
}

void NanoVG::fontFaceId(FontId font)
{
if (fContext == nullptr) return;
DISTRHO_SAFE_ASSERT_RETURN(font >= 0,);

nvgFontFaceId(fContext, font);
}

void NanoVG::fontFace(const char* font)
{
if (fContext == nullptr) return;
DISTRHO_SAFE_ASSERT_RETURN(font != nullptr && font[0] != '\0',);

nvgFontFace(fContext, font);
}

float NanoVG::text(float x, float y, const char* string, const char* end)
{
if (fContext == nullptr) return 0.0f;
DISTRHO_SAFE_ASSERT_RETURN(string != nullptr && string[0] != '\0', 0.0f);

return nvgText(fContext, x, y, string, end);
}

void NanoVG::textBox(float x, float y, float breakRowWidth, const char* string, const char* end)
{
if (fContext == nullptr) return;
DISTRHO_SAFE_ASSERT_RETURN(string != nullptr && string[0] != '\0',);

nvgTextBox(fContext, x, y, breakRowWidth, string, end);
}

float NanoVG::textBounds(float x, float y, const char* string, const char* end, Rectangle<float>& bounds)
{
if (fContext == nullptr) return 0.0f;
DISTRHO_SAFE_ASSERT_RETURN(string != nullptr && string[0] != '\0', 0.0f);

float b[4];
const float ret = nvgTextBounds(fContext, x, y, string, end, b);
bounds = Rectangle<float>(b[0], b[1], b[2], b[3]);
@@ -567,22 +682,31 @@ float NanoVG::textBounds(float x, float y, const char* string, const char* end,

void NanoVG::textBoxBounds(float x, float y, float breakRowWidth, const char* string, const char* end, float* bounds)
{
if (fContext == nullptr) return;
DISTRHO_SAFE_ASSERT_RETURN(string != nullptr && string[0] != '\0',);

nvgTextBoxBounds(fContext, x, y, breakRowWidth, string, end, bounds);
}

int NanoVG::textGlyphPositions(float x, float y, const char* string, const char* end, NanoVG::GlyphPosition* positions, int maxPositions)
{
if (fContext == nullptr) return 0;
DISTRHO_SAFE_ASSERT_RETURN(string != nullptr && string[0] != '\0', 0);

return nvgTextGlyphPositions(fContext, x, y, string, end, (NVGglyphPosition*)positions, maxPositions);
}

void NanoVG::textMetrics(float* ascender, float* descender, float* lineh)
{
nvgTextMetrics(fContext, ascender, descender, lineh);
if (fContext != nullptr)
nvgTextMetrics(fContext, ascender, descender, lineh);
}

int NanoVG::textBreakLines(const char* string, const char* end, float breakRowWidth, NanoVG::TextRow* rows, int maxRows)
{
return nvgTextBreakLines(fContext, string, end, breakRowWidth, (NVGtextRow*)rows, maxRows);
if (fContext != nullptr)
return nvgTextBreakLines(fContext, string, end, breakRowWidth, (NVGtextRow*)rows, maxRows);
return 0;
}

// -----------------------------------------------------------------------


+ 8
- 3
distrho/src/DistrhoUIInternal.hpp View File

@@ -150,8 +150,13 @@ public:
{
DISTRHO_SAFE_ASSERT_RETURN(fUi != nullptr,);

const int width = fUi->d_getWidth();
const int height = fUi->d_getHeight();

fUi->setSize(width, height);

setResizable(false);
setSize(fUi->d_getWidth(), fUi->d_getHeight());
setSize(width, height);
}

~UIExporterWindow()
@@ -174,10 +179,10 @@ protected:
{
DISTRHO_SAFE_ASSERT_RETURN(fUi != nullptr,);

fIsReady = true;

fUi->setSize(width, height);
fUi->d_uiReshape(width, height);

fIsReady = true;
}

private:


Write Preview
Loading…
Cancel
Save