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

dgl/src/NanoVG.cpp

@@ -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;
 }
 
 // -----------------------------------------------------------------------

distrho/src/DistrhoUIInternal.hpp

@@ -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: