void TabWidget::draw(NVGcontext* ctx) {
int tab_height = m_header->preferred_size(ctx).y();
auto active_area = m_header->active_button_area();
for (int i = 0; i < 3; ++i) {
nvgSave(ctx);
if (i == 0)
nvgIntersectScissor(ctx, m_pos.x(), m_pos.y(), active_area.first.x() + 1, m_size.y());
else if (i == 1)
nvgIntersectScissor(ctx, m_pos.x() + active_area.second.x(), m_pos.y(), m_size.x() - active_area.second.x(), m_size.y());
else
nvgIntersectScissor(ctx, m_pos.x(), m_pos.y() + tab_height + 2, m_size.x(), m_size.y());
nvgBeginPath(ctx);
nvgStrokeWidth(ctx, 1.0f);
nvgRoundedRect(ctx, m_pos.x() + 0.5f, m_pos.y() + tab_height + 1.5f, m_size.x() - 1,
m_size.y() - tab_height - 2, m_theme->m_button_corner_radius);
nvgStrokeColor(ctx, m_theme->m_border_light);
nvgStroke(ctx);
nvgBeginPath(ctx);
nvgRoundedRect(ctx, m_pos.x() + 0.5f, m_pos.y() + tab_height + 0.5f, m_size.x() - 1,
m_size.y() - tab_height - 2, m_theme->m_button_corner_radius);
nvgStrokeColor(ctx, m_theme->m_border_dark);
nvgStroke(ctx);
nvgRestore(ctx);
}
Widget::draw(ctx);
}
void drawDropDown(struct NVGcontext* vg, const char* text, float x, float y, float w, float h)
{
struct NVGpaint bg;
char icon[8];
float cornerRadius = 4.0f;
bg = nvgLinearGradient(vg, x,y,x,y+h, nvgRGBA(255,255,255,16), nvgRGBA(0,0,0,16) );
nvgBeginPath(vg);
nvgRoundedRect(vg, x+1,y+1, w-2,h-2, cornerRadius-1);
nvgFillPaint(vg, bg);
nvgFill(vg);
nvgBeginPath(vg);
nvgRoundedRect(vg, x+0.5f,y+0.5f, w-1,h-1, cornerRadius-0.5f);
nvgStrokeColor(vg, nvgRGBA(0,0,0,48) );
nvgStroke(vg);
nvgFontSize(vg, 20.0f);
nvgFontFace(vg, "sans");
nvgFillColor(vg, nvgRGBA(255,255,255,160) );
nvgTextAlign(vg,NVG_ALIGN_LEFT|NVG_ALIGN_MIDDLE);
nvgText(vg, x+h*0.3f,y+h*0.5f,text, NULL);
nvgFontSize(vg, h*1.3f);
nvgFontFace(vg, "icons");
nvgFillColor(vg, nvgRGBA(255,255,255,64) );
nvgTextAlign(vg,NVG_ALIGN_CENTER|NVG_ALIGN_MIDDLE);
nvgText(vg, x+w-h*0.5f, y+h*0.5f, cpToUTF8(ICON_CHEVRON_RIGHT,icon), NULL);
}
void TabWidget::draw(NVGcontext* ctx) {
int tabHeight = mHeader->preferredSize(ctx).y();
auto activeArea = mHeader->activeButtonArea();
for (int i = 0; i < 3; ++i) {
nvgSave(ctx);
if (i == 0)
nvgIntersectScissor(ctx, mPos.x(), mPos.y(), activeArea.first.x() + 1, mSize.y());
else if (i == 1)
nvgIntersectScissor(ctx, mPos.x() + activeArea.second.x(), mPos.y(), mSize.x() - activeArea.second.x(), mSize.y());
else
nvgIntersectScissor(ctx, mPos.x(), mPos.y() + tabHeight + 2, mSize.x(), mSize.y());
nvgBeginPath(ctx);
nvgStrokeWidth(ctx, 1.0f);
nvgRoundedRect(ctx, mPos.x() + 0.5f, mPos.y() + tabHeight + 1.5f, mSize.x() - 1,
mSize.y() - tabHeight - 2, mTheme->mButtonCornerRadius);
nvgStrokeColor(ctx, mTheme->mBorderLight);
nvgStroke(ctx);
nvgBeginPath(ctx);
nvgRoundedRect(ctx, mPos.x() + 0.5f, mPos.y() + tabHeight + 0.5f, mSize.x() - 1,
mSize.y() - tabHeight - 2, mTheme->mButtonCornerRadius);
nvgStrokeColor(ctx, mTheme->mBorderDark);
nvgStroke(ctx);
nvgRestore(ctx);
}
Widget::draw(ctx);
}
void Popup::draw(NVGcontext* ctx) {
refreshRelativePlacement();
if (!mVisible)
return;
int ds = mTheme->mWindowDropShadowSize, cr = mTheme->mWindowCornerRadius;
/* Draw a drop shadow */
NVGpaint shadowPaint = nvgBoxGradient(
ctx, mPos.x(), mPos.y(), mSize.x(), mSize.y(), cr*2, ds*2,
mTheme->mDropShadow, mTheme->mTransparent);
nvgBeginPath(ctx);
nvgRect(ctx, mPos.x()-ds,mPos.y()-ds, mSize.x()+2*ds, mSize.y()+2*ds);
nvgRoundedRect(ctx, mPos.x(), mPos.y(), mSize.x(), mSize.y(), cr);
nvgPathWinding(ctx, NVG_HOLE);
nvgFillPaint(ctx, shadowPaint);
nvgFill(ctx);
/* Draw window */
nvgBeginPath(ctx);
nvgRoundedRect(ctx, mPos.x(), mPos.y(), mSize.x(), mSize.y(), cr);
nvgMoveTo(ctx, mPos.x()-15,mPos.y()+mAnchorHeight);
nvgLineTo(ctx, mPos.x()+1,mPos.y()+mAnchorHeight-15);
nvgLineTo(ctx, mPos.x()+1,mPos.y()+mAnchorHeight+15);
nvgFillColor(ctx, mTheme->mWindowPopup);
nvgFill(ctx);
Widget::draw(ctx);
}
void VScrollPanel::draw (NVGcontext * ctx)
{
if (mChildren.empty())
return;
Widget * child = mChildren[0];
mChildPreferredHeight = child->preferredSize (ctx).y();
float scrollh = height() *
std::min (1.0f, height() / (float) mChildPreferredHeight);
nvgSave (ctx);
nvgTranslate (ctx, mPos.x(), mPos.y());
nvgScissor (ctx, 0, 0, mSize.x(), mSize.y());
nvgTranslate (ctx, 0, -mScroll * (mChildPreferredHeight - mSize.y()));
if (child->visible())
child->draw (ctx);
nvgRestore (ctx);
NVGpaint paint = nvgBoxGradient (
ctx, mPos.x() + mSize.x() - 12 + 1, mPos.y() + 4 + 1, 8,
mSize.y() - 8, 3, 4, Color (0, 32), Color (0, 92));
nvgBeginPath (ctx);
nvgRoundedRect (ctx, mPos.x() + mSize.x() - 12, mPos.y() + 4, 8,
mSize.y() - 8, 3);
nvgFillPaint (ctx, paint);
nvgFill (ctx);
paint = nvgBoxGradient (
ctx, mPos.x() + mSize.x() - 12 - 1,
mPos.y() + 4 + (mSize.y() - 8 - scrollh) * mScroll - 1, 8, scrollh,
3, 4, Color (220, 100), Color (128, 100));
nvgBeginPath (ctx);
nvgRoundedRect (ctx, mPos.x() + mSize.x() - 12 + 1,
mPos.x() + 4 + 1 + (mSize.y() - 8 - scrollh) * mScroll, 8 - 2,
scrollh - 2, 2);
nvgFillPaint (ctx, paint);
nvgFill (ctx);
}
void ProgressBar::draw(NVGcontext* ctx)
{
Widget::draw(ctx);
NVGpaint paint = nvgBoxGradient(
ctx, mPos.x() + 1, mPos.y() + 1,
mSize.x()-2, mSize.y(), 3, 4, Color(0, 32), Color(0, 92));
nvgBeginPath(ctx);
nvgRoundedRect(ctx, mPos.x(), mPos.y(), mSize.x(), mSize.y(), 3);
nvgFillPaint(ctx, paint);
nvgFill(ctx);
float value = std::min(std::max(0.0f, mValue), 1.0f);
int barPos = (int) std::round((mSize.x() - 2) * value);
paint = nvgBoxGradient(
ctx, mPos.x(), mPos.y(),
barPos+1.5f, mSize.y()-1, 3, 4,
Color(220, 100), Color(128, 100));
nvgBeginPath(ctx);
nvgRoundedRect(
ctx, mPos.x()+1, mPos.y()+1,
barPos, mSize.y()-2, 3);
nvgFillPaint(ctx, paint);
nvgFill(ctx);
}
void IterationRunWork::output(run::World& run)
{
// draw background
demo::background( batb, run );
if ( item_ )
{
switch ( item_->mode )
{
case WorkItem::Mode::Definite:
{
//tb_widget_->set( item_->alpha, item_->tag );
const auto& tag = item_->tag;
auto alpha = item_->alpha;
// draw progressbar. FIXME
auto nvg = batb.gl.nanovg_begin( run.scene );
float_t w = 512;
float_t h = 22;
float_t x = 0.5 * (run.scene.wth - w);
float_t y = 0.5 * run.scene.hth + 112;
float_t r = 11;
nvgBeginPath( nvg );
nvgRoundedRect( nvg, x, y, w, h, r );
nvgFillColor( nvg, nvgRGBf( 1.0, 1.0, 1.0 ) );
nvgFill( nvg );
nvgBeginPath( nvg );
nvgRoundedRect( nvg, x, y, alpha * w, h, r );
nvgFillColor( nvg, nvgRGBf( 1.0, 0.22, 0.0 ) );
nvgFill( nvg );
static int font = -1;
if ( font == -1 )
{
font = batb.gl.nanovg_font( "sans", file::static_data( "batb/Ubuntu-Title.ttf" ) );
}
nvgFontSize( nvg, 20 );
nvgTextAlign( nvg, NVG_ALIGN_CENTER | NVG_ALIGN_MIDDLE );
nvgFontFaceId( nvg, font );
nvgFillColor( nvg, nvgRGBf( 0.0, 0.0, 0.0 ) );
//nvgFillColor( nvg, nvgRGBf( 0.11, 0.64, 0.04 ) );
nvgText( nvg, x + 0.5 * w, y + 0.5 * h, tag.c_str(), nullptr );
batb.gl.nanovg_end();
}
break;
case WorkItem::Mode::Indefinite:
// FIXME: draw a finite progressbar/spinner
break;
}
}
}
void drawWindow(struct NVGcontext* vg, const char* title, float x, float y, float w, float h)
{
float cornerRadius = 3.0f;
struct NVGpaint shadowPaint;
struct NVGpaint headerPaint;
nvgSave(vg);
// nvgClearState(vg);
// Window
nvgBeginPath(vg);
nvgRoundedRect(vg, x,y, w,h, cornerRadius);
nvgFillColor(vg, nvgRGBA(28,30,34,192) );
// nvgFillColor(vg, nvgRGBA(0,0,0,128) );
nvgFill(vg);
// Drop shadow
shadowPaint = nvgBoxGradient(vg, x,y+2, w,h, cornerRadius*2, 10, nvgRGBA(0,0,0,128), nvgRGBA(0,0,0,0) );
nvgBeginPath(vg);
nvgRect(vg, x-10,y-10, w+20,h+30);
nvgRoundedRect(vg, x,y, w,h, cornerRadius);
nvgPathWinding(vg, NVG_HOLE);
nvgFillPaint(vg, shadowPaint);
nvgFill(vg);
// Header
headerPaint = nvgLinearGradient(vg, x,y,x,y+15, nvgRGBA(255,255,255,8), nvgRGBA(0,0,0,16) );
nvgBeginPath(vg);
nvgRoundedRect(vg, x+1,y+1, w-2,30, cornerRadius-1);
nvgFillPaint(vg, headerPaint);
nvgFill(vg);
nvgBeginPath(vg);
nvgMoveTo(vg, x+0.5f, y+0.5f+30);
nvgLineTo(vg, x+0.5f+w-1, y+0.5f+30);
nvgStrokeColor(vg, nvgRGBA(0,0,0,32) );
nvgStroke(vg);
nvgFontSize(vg, 18.0f);
nvgFontFace(vg, "sans-bold");
nvgTextAlign(vg,NVG_ALIGN_CENTER|NVG_ALIGN_MIDDLE);
nvgFontBlur(vg,2);
nvgFillColor(vg, nvgRGBA(0,0,0,128) );
nvgText(vg, x+w/2,y+16+1, title, NULL);
nvgFontBlur(vg,0);
nvgFillColor(vg, nvgRGBA(220,220,220,160) );
nvgText(vg, x+w/2,y+16, title, NULL);
nvgRestore(vg);
}
void Slider::draw(NVGcontext* ctx) {
Vector2f center = mPos.cast<float>() + mSize.cast<float>() * 0.5f;
Vector2f knobPos(mPos.x() + mValue * mSize.x(), center.y() + 0.5f);
float kr = (int)(mSize.y()*0.5f);
NVGpaint bg = nvgBoxGradient(ctx,
mPos.x(), center.y() - 3 + 1, mSize.x(), 6, 3, 3, Color(0, mEnabled ? 32 : 10), Color(0, mEnabled ? 128 : 210));
nvgBeginPath(ctx);
nvgRoundedRect(ctx, mPos.x(), center.y() - 3 + 1, mSize.x(), 6, 2);
nvgFillPaint(ctx, bg);
nvgFill(ctx);
if (mHighlightedRange.second != mHighlightedRange.first) {
nvgBeginPath(ctx);
nvgRoundedRect(ctx, mPos.x() + mHighlightedRange.first * mSize.x(), center.y() - 3 + 1, mSize.x() * (mHighlightedRange.second-mHighlightedRange.first), 6, 2);
nvgFillColor(ctx, mHighlightColor);
nvgFill(ctx);
}
NVGpaint knobShadow = nvgRadialGradient(ctx,
knobPos.x(), knobPos.y(), kr-3, kr+3, Color(0, 64), mTheme->mTransparent);
nvgBeginPath(ctx);
nvgRect(ctx, knobPos.x() - kr - 5, knobPos.y() - kr - 5, kr*2+10, kr*2+10+3);
nvgCircle(ctx, knobPos.x(), knobPos.y(), kr);
nvgPathWinding(ctx, NVG_HOLE);
nvgFillPaint(ctx, knobShadow);
nvgFill(ctx);
NVGpaint knob = nvgLinearGradient(ctx,
mPos.x(), center.y() - kr, mPos.x(), center.y() + kr,
mTheme->mBorderLight, mTheme->mBorderMedium);
NVGpaint knobReverse = nvgLinearGradient(ctx,
mPos.x(), center.y() - kr, mPos.x(), center.y() + kr,
mTheme->mBorderMedium,
mTheme->mBorderLight);
nvgBeginPath(ctx);
nvgCircle(ctx, knobPos.x(), knobPos.y(), kr);
nvgStrokeColor(ctx, mTheme->mBorderDark);
nvgFillPaint(ctx, knob);
nvgStroke(ctx);
nvgFill(ctx);
nvgBeginPath(ctx);
nvgCircle(ctx, knobPos.x(), knobPos.y(), kr/2);
nvgFillColor(ctx, Color(150, mEnabled ? 255 : 100));
nvgStrokePaint(ctx, knobReverse);
nvgStroke(ctx);
nvgFill(ctx);
}
void drawEditBoxBase(struct NVGcontext* vg, float x, float y, float w, float h)
{
struct NVGpaint bg;
// Edit
bg = nvgBoxGradient(vg, x+1,y+1+1.5f, w-2,h-2, 3,4, nvgRGBA(255,255,255,32), nvgRGBA(32,32,32,32) );
nvgBeginPath(vg);
nvgRoundedRect(vg, x+1,y+1, w-2,h-2, 4-1);
nvgFillPaint(vg, bg);
nvgFill(vg);
nvgBeginPath(vg);
nvgRoundedRect(vg, x+0.5f,y+0.5f, w-1,h-1, 4-0.5f);
nvgStrokeColor(vg, nvgRGBA(0,0,0,48) );
nvgStroke(vg);
}
void drawButton(struct NVGcontext* vg, int preicon, const char* text, float x, float y, float w, float h, struct NVGcolor col)
{
struct NVGpaint bg;
char icon[8];
float cornerRadius = 4.0f;
float tw = 0, iw = 0;
bg = nvgLinearGradient(vg, x,y,x,y+h, nvgRGBA(255,255,255,isBlack(col)?16:32), nvgRGBA(0,0,0,isBlack(col)?16:32) );
nvgBeginPath(vg);
nvgRoundedRect(vg, x+1,y+1, w-2,h-2, cornerRadius-1);
if (!isBlack(col) ) {
nvgFillColor(vg, col);
nvgFill(vg);
}
nvgFillPaint(vg, bg);
nvgFill(vg);
nvgBeginPath(vg);
nvgRoundedRect(vg, x+0.5f,y+0.5f, w-1,h-1, cornerRadius-0.5f);
nvgStrokeColor(vg, nvgRGBA(0,0,0,48) );
nvgStroke(vg);
nvgFontSize(vg, 20.0f);
nvgFontFace(vg, "sans-bold");
tw = nvgTextBounds(vg, 0,0, text, NULL, NULL);
if (preicon != 0) {
nvgFontSize(vg, h*1.3f);
nvgFontFace(vg, "icons");
iw = nvgTextBounds(vg, 0,0, cpToUTF8(preicon,icon), NULL, NULL);
iw += h*0.15f;
}
if (preicon != 0) {
nvgFontSize(vg, h*1.3f);
nvgFontFace(vg, "icons");
nvgFillColor(vg, nvgRGBA(255,255,255,96) );
nvgTextAlign(vg,NVG_ALIGN_LEFT|NVG_ALIGN_MIDDLE);
nvgText(vg, x+w*0.5f-tw*0.5f-iw*0.75f, y+h*0.5f, cpToUTF8(preicon,icon), NULL);
}
nvgFontSize(vg, 20.0f);
nvgFontFace(vg, "sans-bold");
nvgTextAlign(vg,NVG_ALIGN_LEFT|NVG_ALIGN_MIDDLE);
nvgFillColor(vg, nvgRGBA(0,0,0,160) );
nvgText(vg, x+w*0.5f-tw*0.5f+iw*0.25f,y+h*0.5f-1,text, NULL);
nvgFillColor(vg, nvgRGBA(255,255,255,160) );
nvgText(vg, x+w*0.5f-tw*0.5f+iw*0.25f,y+h*0.5f,text, NULL);
}
void CheckBox::draw(NVGcontext *ctx) {
Widget::draw(ctx);
nvgFontSize(ctx, fontSize());
nvgFontFace(ctx, "sans");
nvgFillColor(ctx,
mEnabled ? mTheme->mTextColor : mTheme->mDisabledTextColor);
nvgTextAlign(ctx, NVG_ALIGN_LEFT | NVG_ALIGN_MIDDLE);
nvgText(ctx, mPos.x + 1.2f * mSize.y + 5, mPos.y + mSize.y * 0.5f,
mCaption.c_str(), nullptr);
NVGpaint bg = nvgBoxGradient(ctx, mPos.x + 1.5f, mPos.y + 1.5f,
mSize.y - 2.0f, mSize.y - 2.0f, 3, 3,
mPushed ? Color(0, 100) : Color(0, 32),
Color(0, 0, 0, 180));
nvgBeginPath(ctx);
nvgRoundedRect(ctx, mPos.x + 1.0f, mPos.y + 1.0f, mSize.y - 2.0f,
mSize.y - 2.0f, 3);
nvgFillPaint(ctx, bg);
nvgFill(ctx);
if (mChecked) {
nvgFontSize(ctx, 1.8 * mSize.y);
nvgFontFace(ctx, "icons");
nvgFillColor(ctx, mEnabled ? mTheme->mIconColor
: mTheme->mDisabledTextColor);
nvgTextAlign(ctx, NVG_ALIGN_CENTER | NVG_ALIGN_MIDDLE);
nvgText(ctx, mPos.x + mSize.y * 0.5f + 1,
mPos.y + mSize.y * 0.5f, utf8(ENTYPO_ICON_CHECK).data(),
nullptr);
}
}
int main() {
glfwInit();
glfwDefaultWindowHints();
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1);
GLFWwindow *window = glfwCreateWindow(800, 600, "nanovg Demo", nullptr, nullptr);
NVGcontext *vg = nvgCreateGL3(NVG_ANTIALIAS | NVG_STENCIL_STROKES | NVG_DEBUG);
while (!glfwWindowShouldClose(window)) {
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT);
nvgBeginFrame(vg, 800, 600, 1);
nvgBeginPath(vg);
nvgRoundedRect(vg, 12, 12, 800-12*2, 600-12*2, 4);
nvgFillColor(vg, nvgRGBA(255, 255, 255, 192));
nvgFill(vg);
nvgEndFrame(vg);
glfwSwapBuffers(window);
glfwPollEvents();
}
glfwDestroyWindow(window);
glfwTerminate();
return 0;
}
void drawCheckBox(struct NVGcontext* vg, const char* text, float x, float y, float w, float h)
{
struct NVGpaint bg;
char icon[8];
NVG_NOTUSED(w);
nvgFontSize(vg, 18.0f);
nvgFontFace(vg, "sans");
nvgFillColor(vg, nvgRGBA(255,255,255,160) );
nvgTextAlign(vg,NVG_ALIGN_LEFT|NVG_ALIGN_MIDDLE);
nvgText(vg, x+28,y+h*0.5f,text, NULL);
bg = nvgBoxGradient(vg, x+1,y+(int)(h*0.5f)-9+1, 18,18, 3,3, nvgRGBA(0,0,0,32), nvgRGBA(0,0,0,92) );
nvgBeginPath(vg);
nvgRoundedRect(vg, x+1,y+(int)(h*0.5f)-9, 18,18, 3);
nvgFillPaint(vg, bg);
nvgFill(vg);
nvgFontSize(vg, 40);
nvgFontFace(vg, "icons");
nvgFillColor(vg, nvgRGBA(255,255,255,128) );
nvgTextAlign(vg,NVG_ALIGN_CENTER|NVG_ALIGN_MIDDLE);
nvgText(vg, x+9+2, y+h*0.5f, cpToUTF8(ICON_CHECK,icon), NULL);
}
void Renderer2D::drawRoundedRectangle( const attributes_2d& attributes, const float32_t& width, const float32_t& height,
const float32_t& corner, const float32_t& border, const color_argb& color, const color_argb& borderColor,
const Image2D& image, const float32_t& image_alpha, const float32_t& image_pos_x,
const float32_t& image_pos_y, const float32_t& image_width, const float32_t& image_height,
const float32_t& image_rotation )
{
Context2D* context = _context2D;
const float32_t sWidth = width * attributes.scale;
const float32_t sHeight = height * attributes.scale;
nvgSave( context );
nvgBeginPath( context );
nvgTranslate( context, attributes.position[0], attributes.position[1]);
nvgSave( context );
nvgRotate( context, attributes.rotation );
nvgRoundedRect( context, -sWidth/2, -sHeight/2, sWidth, sHeight, corner );
if( image != 0 )
{
NVGpaint paint = nvgImagePattern( context, image_pos_x-image_width/2,
image_pos_y-image_height/2, image_width, image_height, image_rotation, image, image_alpha );
nvgFillPaint( context, paint);
}
else
{
nvgFillColor( context, nvgRGBA( color.r, color.g, color.b, color.a) );
}
nvgFill(context);
nvgStrokeColor( context, nvgRGBA( borderColor.r, borderColor.g, borderColor.b, borderColor.a) );
nvgStrokeWidth( context, border );
nvgStroke( context );
nvgRestore( context );
nvgRestore( context );
}
virtual void updateGL( osg::State* state ) const
{
// Some test drawings...
nvgBeginPath( _vg );
nvgRect( _vg, 300, 300, 120, 30 );
nvgFillColor( _vg, nvgRGBA(255, 192, 0, 255) );
nvgFill( _vg );
nvgClosePath( _vg );
nvgBeginPath( _vg );
nvgCircle( _vg, 400, 500, 50 );
nvgFillColor( _vg, nvgRGBA(0, 192, 255, 100) );
nvgFill( _vg );
nvgClosePath( _vg );
if ( _loadedImages.size()>0 )
{
NVGpaint imgPaint = nvgImagePattern( _vg, 600, 150, 300, 400, 0.0f,
_loadedImages[0], 1.0f );
nvgBeginPath( _vg );
nvgRoundedRect( _vg, 600, 150, 300, 400, 5 );
nvgFillPaint( _vg, imgPaint );
nvgFill( _vg );
nvgClosePath( _vg );
}
}
static void drawRoundedRect(float x, float y, float w, float h, float r, float fth, unsigned int col)
{
nvgBeginPath(vg::ctx);
nvgFillColor(vg::ctx, nvgRGBA(col&0xff, (col>>8)&0xff, (col>>16)&0xff, (col>>24)&0xff));
nvgRoundedRect(vg::ctx, x, y, w, h, r);
nvgFill(vg::ctx);
}
void ImagePanel::draw (NVGcontext * ctx)
{
ivec2 grid = gridSize();
for (size_t i = 0; i < mImages.size(); ++i)
{
ivec2 p = mPos + ivec2 (mMargin) +
ivec2 ((int)i % grid.x, (int)i / grid.x) * (mThumbSize + mSpacing);
int imgw, imgh;
nvgImageSize (ctx, mImages[i].first, &imgw, &imgh);
float iw, ih, ix, iy;
if (imgw < imgh)
{
iw = mThumbSize;
ih = iw * (float)imgh / (float)imgw;
ix = 0;
iy = - (ih - mThumbSize) * 0.5f;
}
else
{
ih = mThumbSize;
iw = ih * (float)imgw / (float)imgh;
ix = - (iw - mThumbSize) * 0.5f;
iy = 0;
}
NVGpaint imgPaint = nvgImagePattern (
ctx, p.x + ix, p.y + iy, iw, ih, 0, mImages[i].first,
mMouseIndex == (int)i ? 1.0 : 0.7);
nvgBeginPath (ctx);
nvgRoundedRect (ctx, p.x, p.y, mThumbSize, mThumbSize, 5);
nvgFillPaint (ctx, imgPaint);
nvgFill (ctx);
NVGpaint shadowPaint =
nvgBoxGradient (ctx, p.x - 1, p.y, mThumbSize + 2, mThumbSize + 2, 5, 3,
nvgRGBA (0, 0, 0, 128), nvgRGBA (0, 0, 0, 0));
nvgBeginPath (ctx);
nvgRect (ctx, p.x - 5, p.y - 5, mThumbSize + 10, mThumbSize + 10);
nvgRoundedRect (ctx, p.x, p.y, mThumbSize, mThumbSize, 6);
nvgPathWinding (ctx, NVG_HOLE);
nvgFillPaint (ctx, shadowPaint);
nvgFill (ctx);
nvgBeginPath (ctx);
nvgRoundedRect (ctx, p.x + 0.5f, p.y + 0.5f, mThumbSize - 1, mThumbSize - 1, 4 - 0.5f);
nvgStrokeWidth (ctx, 1.0f);
nvgStrokeColor (ctx, nvgRGBA (255, 255, 255, 80));
nvgStroke (ctx);
}
}
void Screen::drawWidgets() {
if (!mVisible)
return;
glfwMakeContextCurrent(mGLFWWindow);
glfwGetFramebufferSize(mGLFWWindow, &mFBSize[0], &mFBSize[1]);
glfwGetWindowSize(mGLFWWindow, &mSize[0], &mSize[1]);
glViewport(0, 0, mFBSize[0], mFBSize[1]);
/* Calculate pixel ratio for hi-dpi devices. */
mPixelRatio = (float) mFBSize[0] / (float) mSize[0];
nvgBeginFrame(mNVGContext, mSize[0], mSize[1], mPixelRatio);
draw(mNVGContext);
double elapsed = glfwGetTime() - mLastInteraction;
if (elapsed > 0.5f) {
/* Draw tooltips */
const Widget *widget = findWidget(mMousePos);
if (widget && !widget->tooltip().empty()) {
int tooltipWidth = 150;
float bounds[4];
nvgFontFace(mNVGContext, "sans");
nvgFontSize(mNVGContext, 15.0f);
nvgTextAlign(mNVGContext, NVG_ALIGN_CENTER | NVG_ALIGN_TOP);
nvgTextLineHeight(mNVGContext, 1.1f);
Vector2i pos = widget->absolutePosition() +
Vector2i(widget->width() / 2, widget->height() + 10);
nvgTextBoxBounds(mNVGContext, pos.x(), pos.y(), tooltipWidth,
widget->tooltip().c_str(), nullptr, bounds);
nvgGlobalAlpha(mNVGContext,
std::min(1.0, 2 * (elapsed - 0.5f)) * 0.8);
nvgBeginPath(mNVGContext);
nvgFillColor(mNVGContext, Color(0, 255));
int h = (bounds[2] - bounds[0]) / 2;
nvgRoundedRect(mNVGContext, bounds[0] - 4 - h, bounds[1] - 4,
(int) (bounds[2] - bounds[0]) + 8,
(int) (bounds[3] - bounds[1]) + 8, 3);
int px = (int) ((bounds[2] + bounds[0]) / 2) - h;
nvgMoveTo(mNVGContext, px, bounds[1] - 10);
nvgLineTo(mNVGContext, px + 7, bounds[1] + 1);
nvgLineTo(mNVGContext, px - 7, bounds[1] + 1);
nvgFill(mNVGContext);
nvgFillColor(mNVGContext, Color(255, 255));
nvgFontBlur(mNVGContext, 0.0f);
nvgTextBox(mNVGContext, pos.x() - h, pos.y(), tooltipWidth,
widget->tooltip().c_str(), nullptr);
}
}
nvgEndFrame(mNVGContext);
}
static void
draw_rect(NVGcontext *ctx, float x, float y, float w, float h, float r, const gui_byte* c)
{
nvgBeginPath(ctx);
nvgRoundedRect(ctx, x, y, w, h, r);
nvgFillColor(ctx, nvgRGBA(c[0], c[1], c[2], c[3]));
nvgFill(ctx);
}
static void
draw_rect(NVGcontext *ctx, float x, float y, float w, float h, float r, struct gui_color c)
{
nvgBeginPath(ctx);
nvgRoundedRect(ctx, x, y, w, h, r);
nvgFillColor(ctx, nvgRGBA(c.r, c.g, c.b, c.a));
nvgFill(ctx);
}
void VScrollPanel::draw(NVGcontext *ctx) {
if (m_children.empty())
return;
Widget *child = m_children[0];
child->set_position(Vector2i(0, -m_scroll*(m_child_preferred_height - m_size.y())));
m_child_preferred_height = child->preferred_size(ctx).y();
float scrollh = height() *
std::min(1.0f, height() / (float) m_child_preferred_height);
if (m_update_layout) {
m_update_layout = false;
child->perform_layout(ctx);
}
nvgSave(ctx);
nvgTranslate(ctx, m_pos.x(), m_pos.y());
nvgIntersectScissor(ctx, 0, 0, m_size.x(), m_size.y());
if (child->visible())
child->draw(ctx);
nvgRestore(ctx);
if (m_child_preferred_height <= m_size.y())
return;
NVGpaint paint = nvgBoxGradient(
ctx, m_pos.x() + m_size.x() - 12 + 1, m_pos.y() + 4 + 1, 8,
m_size.y() - 8, 3, 4, Color(0, 32), Color(0, 92));
nvgBeginPath(ctx);
nvgRoundedRect(ctx, m_pos.x() + m_size.x() - 12, m_pos.y() + 4, 8,
m_size.y() - 8, 3);
nvgFillPaint(ctx, paint);
nvgFill(ctx);
paint = nvgBoxGradient(
ctx, m_pos.x() + m_size.x() - 12 - 1,
m_pos.y() + 4 + (m_size.y() - 8 - scrollh) * m_scroll - 1, 8, scrollh,
3, 4, Color(220, 100), Color(128, 100));
nvgBeginPath(ctx);
nvgRoundedRect(ctx, m_pos.x() + m_size.x() - 12 + 1,
m_pos.y() + 4 + 1 + (m_size.y() - 8 - scrollh) * m_scroll, 8 - 2,
scrollh - 2, 2);
nvgFillPaint(ctx, paint);
nvgFill(ctx);
}
void Console::draw(NVGcontext* ctx){
Widget::draw(ctx);
//Screen *sc = dynamic_cast<Screen *>(this->window()->parent());
// Draw rounded rectangel around text area ////////////////////
NVGpaint paint = nvgBoxGradient(
ctx, mPos.x() + 1, mPos.y() + 1,
mSize.x()-2, mSize.y(), 3, 4, Color(0, 32), Color(0, 92));
nvgBeginPath(ctx);
nvgRoundedRect(ctx, mPos.x(), mPos.y(), mSize.x(), mSize.y(), 3);
nvgFillPaint(ctx, paint);
nvgFill(ctx);
///////////////////////////////////////////////////////////////
nvgFontSize(ctx, 18.0f);
nvgFontFace(ctx, "sans");
nvgTextAlign(ctx, NVG_ALIGN_LEFT|NVG_ALIGN_TOP);
float x, y, linew, lineh;
nvgTextMetrics(ctx, nullptr, nullptr, &lineh);
x = mPos.x();
y = mPos.y();
linew = mSize.x();
mNumRows = mSize.y()/lineh ; // make sure that the size of console is updated
//setSize(Vector2i(mSize.x(), nrows*lineh)); // this code does not work. It
//changes size each frame. Move from draw into one time function.
// init console output
if(mInit) {
initBuffer(ctx, linew);
mInit = false;
}
//typedef std::deque<std::string> Buffer_t;
//temp solution: when buffer is not full. Move this to updateFunction.
for(auto it = mBuffer.begin();it!=mBuffer.end();++it) {
nvgBeginPath(ctx);
nvgFillColor(ctx, nvgRGBA(255,255,255,16));
nvgRect(ctx, x, y, linew, lineh);
nvgFill(ctx);
nvgFillColor(ctx, nvgRGBA(255,255,255,255));
nvgText(ctx, x, y, it->c_str(), nullptr);
y += lineh;
}
updateCursor(ctx, lineh);
//update cursor and draw
//mCaret.onClick(ctx, lineh, mMouseDownPos - mPos);
mCaret.draw(ctx, lineh, mPos);
}
static void
draw_image(NVGcontext *ctx, gui_handle img, float x, float y, float w, float h, float r)
{
NVGpaint imgpaint;
imgpaint = nvgImagePattern(ctx, x, y, w, h, 0, img.id, 1.0f);
nvgBeginPath(ctx);
nvgRoundedRect(ctx, x, y, w, h, r);
nvgFillPaint(ctx, imgpaint);
nvgFill(ctx);
}
void drawSlider(struct NVGcontext* vg, float pos, float x, float y, float w, float h)
{
struct NVGpaint bg, knob;
float cy = y+(int)(h*0.5f);
float kr = (float)( (int)(h*0.25f) );
nvgSave(vg);
// nvgClearState(vg);
// Slot
bg = nvgBoxGradient(vg, x,cy-2+1, w,4, 2,2, nvgRGBA(0,0,0,32), nvgRGBA(0,0,0,128) );
nvgBeginPath(vg);
nvgRoundedRect(vg, x,cy-2, w,4, 2);
nvgFillPaint(vg, bg);
nvgFill(vg);
// Knob Shadow
bg = nvgRadialGradient(vg, x+(int)(pos*w),cy+1, kr-3,kr+3, nvgRGBA(0,0,0,64), nvgRGBA(0,0,0,0) );
nvgBeginPath(vg);
nvgRect(vg, x+(int)(pos*w)-kr-5,cy-kr-5,kr*2+5+5,kr*2+5+5+3);
nvgCircle(vg, x+(int)(pos*w),cy, kr);
nvgPathWinding(vg, NVG_HOLE);
nvgFillPaint(vg, bg);
nvgFill(vg);
// Knob
knob = nvgLinearGradient(vg, x,cy-kr,x,cy+kr, nvgRGBA(255,255,255,16), nvgRGBA(0,0,0,16) );
nvgBeginPath(vg);
nvgCircle(vg, x+(int)(pos*w),cy, kr-1);
nvgFillColor(vg, nvgRGBA(40,43,48,255) );
nvgFill(vg);
nvgFillPaint(vg, knob);
nvgFill(vg);
nvgBeginPath(vg);
nvgCircle(vg, x+(int)(pos*w),cy, kr-0.5f);
nvgStrokeColor(vg, nvgRGBA(0,0,0,92) );
nvgStroke(vg);
nvgRestore(vg);
}
bool Button::Draw(NVGcontext *context, float deltaTime)
{
if (Widget::Draw(context, deltaTime)) return true;
// Draw the default button here
nvgBeginPath(context);
nvgRoundedRect(context, bounds.position.x, bounds.position.y, bounds.size.x - 4, bounds.size.y - 4, 20);
nvgStrokeWidth(context, 2);
nvgStrokeColor(context, nvgRGB(100, 100, 100));
nvgFillColor(context, nvgRGB(240, 240, 240));
if (mouseInsideWidgetBounds())
{
nvgFillColor(context, nvgRGB(220, 220, 220));
}
nvgFill(context);
nvgStroke(context);
return true;
}
void t2Image::drawInRounedRect(int x, int y, int width, int height, float radius, int angle /*= 0*/, int alpha /*= 255*/, bool bFill /*= true*/)
{
NVGpaint imgPaint = nvgImagePattern(t2GetContext(), x, y, width, height, angle / 255.0f, img, alpha / 255.0f);
nvgBeginPath(t2GetContext());
if(!bFill)
nvgStrokeWidth(t2GetContext(), strokeWidth);
nvgRoundedRect(t2GetContext(), x, y, width, height, radius);
if(bFill)
{
nvgFillPaint(t2GetContext(), imgPaint);
nvgFill(t2GetContext());
}
else
{
nvgStrokePaint(t2GetContext(), imgPaint);
nvgStroke(t2GetContext());
}
}
//Render a rectangle
bool renderRect(Skin::SkinClass::Attributes &skinClass, float x, float y, float sw, float sh) {
if (!m_inited) return false;
NVGcolor col = nvgRGBA(skinClass.fill.r, skinClass.fill.g, skinClass.fill.b, skinClass.fill.a);
//NVGpaint bg = nvgLinearGradient(m_vg, pos.x, pos.y, pos.x, pos.y + size.y, nvgRGBA(255,255,255,isBlack(col)?16:64), nvgRGBA(0,0,0,isBlack(col)?16:64));
nvgBeginPath(m_vg);
nvgRoundedRect(m_vg, x, y, sw, sh, skinClass.cornerRadius);
if (!skinClass.hasImage || skinClass.hasFill) {
nvgFillColor(m_vg, col);
nvgFill(m_vg);
}
if (skinClass.hasImage) {
//int w = size.x, h= size.y;
//nvgImageSize(m_vg, skinClass.imageHandle, &w, &h);
NVGpaint img = nvgImagePattern(m_vg, x, y, sw, sh, 0.f, skinClass.imageHandle, col.a);
nvgFillPaint(m_vg, img);
nvgFill(m_vg);
}
if (skinClass.hasGradient) {
NVGpaint g = nvgLinearGradient(m_vg, x, y, x, y + sh,
nvgRGBA(skinClass.gradientA.r, skinClass.gradientA.g, skinClass.gradientA.b, skinClass.gradientA.a),
nvgRGBA(skinClass.gradientB.r, skinClass.gradientB.g, skinClass.gradientB.b, skinClass.gradientB.a)
);
nvgFillPaint(m_vg, g);
nvgFill(m_vg);
}
if (skinClass.hasStroke) {
nvgStrokeWidth(m_vg, skinClass.strokeWidth);
nvgStrokeColor(m_vg, nvgRGBA(skinClass.stroke.r, skinClass.stroke.g, skinClass.stroke.b, skinClass.stroke.a));
nvgStroke(m_vg);
}
return true;
}
void drawSearchBox(struct NVGcontext* vg, const char* text, float x, float y, float w, float h)
{
struct NVGpaint bg;
char icon[8];
float cornerRadius = h/2-1;
// Edit
bg = nvgBoxGradient(vg, x,y+1.5f, w,h, h/2,5, nvgRGBA(0,0,0,16), nvgRGBA(0,0,0,92) );
nvgBeginPath(vg);
nvgRoundedRect(vg, x,y, w,h, cornerRadius);
nvgFillPaint(vg, bg);
nvgFill(vg);
/* nvgBeginPath(vg);
nvgRoundedRect(vg, x+0.5f,y+0.5f, w-1,h-1, cornerRadius-0.5f);
nvgStrokeColor(vg, nvgRGBA(0,0,0,48) );
nvgStroke(vg);*/
nvgFontSize(vg, h*1.3f);
nvgFontFace(vg, "icons");
nvgFillColor(vg, nvgRGBA(255,255,255,64) );
nvgTextAlign(vg,NVG_ALIGN_CENTER|NVG_ALIGN_MIDDLE);
nvgText(vg, x+h*0.55f, y+h*0.55f, cpToUTF8(ICON_SEARCH,icon), NULL);
nvgFontSize(vg, 20.0f);
nvgFontFace(vg, "sans");
nvgFillColor(vg, nvgRGBA(255,255,255,32) );
nvgTextAlign(vg,NVG_ALIGN_LEFT|NVG_ALIGN_MIDDLE);
nvgText(vg, x+h*1.05f,y+h*0.5f,text, NULL);
nvgFontSize(vg, h*1.3f);
nvgFontFace(vg, "icons");
nvgFillColor(vg, nvgRGBA(255,255,255,32) );
nvgTextAlign(vg,NVG_ALIGN_CENTER|NVG_ALIGN_MIDDLE);
nvgText(vg, x+w-h*0.55f, y+h*0.55f, cpToUTF8(ICON_CIRCLED_CROSS,icon), NULL);
}
void nvgRoundedRect(NVGcontext* ctx, Rect rect, float r){
nvgRoundedRect(ctx,rect.x,rect.y,rect.width,rect.height,r);
}
