void HSeparator::Draw(nux::GraphicsEngine &GfxContext, bool force_draw)
{
nux::Geometry const& base = GetGeometry();
int y0 = base.y + base.GetHeight() / 2;
unsigned int alpha = 0, src = 0, dest = 0;
GfxContext.GetRenderStates().GetBlend(alpha, src, dest);
nux::GetGraphicsDisplay()->GetGraphicsEngine()->GetRenderStates().SetBlend(true, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
if (base.GetWidth() - 2 * border_size_ > 0)
{
nux::Color color0 = color_ * alpha0_;
nux::Color color1 = color_ * alpha1_;
nux::GetPainter().Draw2DLine(GfxContext, base.x, y0, base.x + border_size_, y0, color0, color1);
nux::GetPainter().Draw2DLine(GfxContext, base.x + border_size_, y0, base.x + base.GetWidth() - border_size_, y0, color1, color1);
nux::GetPainter().Draw2DLine(GfxContext, base.x + base.GetWidth() - border_size_, y0, base.x + base.GetWidth(), y0, color1, color0);
}
else
{
nux::Color color1 = color_ * alpha1_;
nux::GetPainter().Draw2DLine(GfxContext, base.x, y0, base.x + base.GetWidth(), y0, color1, color1);
}
GfxContext.GetRenderStates().SetBlend(alpha, src, dest);
}
void UserPromptView::DrawContent(nux::GraphicsEngine& graphics_engine, bool force_draw)
{
nux::Geometry const& geo = GetGeometry();
graphics_engine.PushClippingRectangle(geo);
if (!IsFullRedraw())
{
bg_layer_.reset(CrateBackgroundLayer(geo.width, geo.height));
nux::GetPainter().PushLayer(graphics_engine, geo, bg_layer_.get());
}
if (caps_lock_on_)
{
for (auto const& text_entry : focus_queue_)
PaintWarningIcon(graphics_engine, text_entry->GetGeometry());
if (focus_queue_.empty())
PaintWarningIcon(graphics_engine, cached_focused_geo_);
}
if (GetLayout())
GetLayout()->ProcessDraw(graphics_engine, force_draw);
if (!IsFullRedraw())
nux::GetPainter().PopBackground();
graphics_engine.PopClippingRectangle();
}
void ApplicationPreview::Draw(nux::GraphicsEngine& gfx_engine, bool force_draw)
{
nux::Geometry const& base = GetGeometry();
gfx_engine.PushClippingRectangle(base);
nux::GetPainter().PaintBackground(gfx_engine, base);
gfx_engine.PopClippingRectangle();
}
void PreviewRatingsWidget::DrawContent(nux::GraphicsEngine& gfx_engine, bool force_draw)
{
nux::Geometry const& base = GetGeometry();
gfx_engine.PushClippingRectangle(base);
if (GetCompositionLayout())
GetCompositionLayout()->ProcessDraw(gfx_engine, force_draw);
gfx_engine.PopClippingRectangle();
}
void OverlaySpinner::Draw(nux::GraphicsEngine& GfxContext, bool force_draw)
{
nux::Geometry const& geo = GetGeometry();
nux::TexCoordXForm texxform;
GfxContext.PushClippingRectangle(geo);
nux::GetPainter().PaintBackground(GfxContext, geo);
texxform.SetTexCoordType(nux::TexCoordXForm::OFFSET_COORD);
texxform.SetWrap(nux::TEXWRAP_REPEAT, nux::TEXWRAP_REPEAT);
texxform.min_filter = nux::TEXFILTER_LINEAR;
texxform.mag_filter = nux::TEXFILTER_LINEAR;
unsigned int current_alpha_blend;
unsigned int current_src_blend_factor;
unsigned int current_dest_blend_factor;
GfxContext.GetRenderStates().GetBlend(current_alpha_blend, current_src_blend_factor, current_dest_blend_factor);
GfxContext.GetRenderStates().SetBlend(true, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
nux::Geometry spin_geo(geo.x + ((geo.width - spin_->GetWidth()) / 2),
geo.y + ((geo.height - spin_->GetHeight()) / 2),
spin_->GetWidth(),
spin_->GetHeight());
// Geometry (== Rect) uses integers which were rounded above,
// hence an extra 0.5 offset for odd sizes is needed
// because pure floating point is not being used.
int spin_offset_w = !(geo.width % 2) ? 0 : 1;
int spin_offset_h = !(geo.height % 2) ? 0 : 1;
nux::Matrix4 matrix_texture;
matrix_texture = nux::Matrix4::TRANSLATE(-spin_geo.x - (spin_geo.width + spin_offset_w) / 2.0f,
-spin_geo.y - (spin_geo.height + spin_offset_h) / 2.0f, 0) * matrix_texture;
matrix_texture = rotate_ * matrix_texture;
matrix_texture = nux::Matrix4::TRANSLATE(spin_geo.x + (spin_geo.width + spin_offset_w) / 2.0f,
spin_geo.y + (spin_geo.height + spin_offset_h) / 2.0f, 0) * matrix_texture;
GfxContext.SetModelViewMatrix(GfxContext.GetModelViewMatrix() * matrix_texture);
GfxContext.QRP_1Tex(spin_geo.x,
spin_geo.y,
spin_geo.width,
spin_geo.height,
spin_->GetDeviceTexture(),
texxform,
nux::color::White);
// revert to model view matrix stack
GfxContext.ApplyModelViewMatrix();
GfxContext.PopClippingRectangle();
GfxContext.GetRenderStates().SetBlend(current_alpha_blend, current_src_blend_factor, current_dest_blend_factor);
if (!frame_timeout_)
{
frame_timeout_.reset(new glib::Timeout(22, sigc::mem_fun(this, &OverlaySpinner::OnFrameTimeout)));
}
}
void HudButton::DrawContent(nux::GraphicsEngine& GfxContext, bool force_draw)
{
if (skip_draw_)
return;
if (IsFullRedraw())
{
GfxContext.PushClippingRectangle(GetGeometry());
hlayout_->ProcessDraw(GfxContext, force_draw);
GfxContext.PopClippingRectangle();
}
}
void UserPromptView::Draw(nux::GraphicsEngine& graphics_engine, bool /* force_draw */)
{
nux::Geometry const& geo = GetGeometry();
graphics_engine.PushClippingRectangle(geo);
nux::GetPainter().PaintBackground(graphics_engine, geo);
EnsureBGLayer();
nux::GetPainter().PushDrawLayer(graphics_engine, geo, bg_layer_.get());
nux::GetPainter().PopBackground();
graphics_engine.PopClippingRectangle();
}
void ApplicationPreview::DrawContent(nux::GraphicsEngine& gfx_engine, bool force_draw)
{
nux::Geometry const& base = GetGeometry();
gfx_engine.PushClippingRectangle(base);
unsigned int alpha, src, dest = 0;
gfx_engine.GetRenderStates().GetBlend(alpha, src, dest);
gfx_engine.GetRenderStates().SetBlend(true, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
if (GetCompositionLayout())
GetCompositionLayout()->ProcessDraw(gfx_engine, force_draw);
gfx_engine.GetRenderStates().SetBlend(alpha, src, dest);
gfx_engine.PopClippingRectangle();
}
virtual void DrawContent(nux::GraphicsEngine& gfx_engine, bool force_draw)
{
nux::Geometry const& base = GetGeometry();
gfx_engine.PushClippingRectangle(base);
if (!IsFullRedraw())
nux::GetPainter().PushLayer(gfx_engine, GetGeometry(), bg_layer_.get());
if (GetCompositionLayout())
GetCompositionLayout()->ProcessDraw(gfx_engine, force_draw);
if (!IsFullRedraw())
nux::GetPainter().PopBackground();
gfx_engine.PopClippingRectangle();
}
void PlacesOverlayVScrollBar::Draw(nux::GraphicsEngine& graphics_engine, bool force_draw)
{
PlacesVScrollBar::Draw(graphics_engine, force_draw);
if (connector_height_ > 0 && connector_texture_.IsValid())
{
int const connector_width = GetBaseWidth();
int offset_y = 0;
if (thumb_above_slider_)
{
offset_y = _slider->GetBaseY() - connector_height_;
}
else
{
offset_y = _slider->GetBaseY() + _slider->GetBaseHeight();
}
nux::Geometry base(_track->GetBaseX(), offset_y - 4, connector_width, connector_height_ + 5);
nux::TexCoordXForm texxform;
graphics_engine.QRP_1Tex(base.x,
base.y,
base.width,
base.height,
connector_texture_->GetDeviceTexture(),
texxform,
nux::color::White);
}
}
void FilterBar::DrawContent(nux::GraphicsEngine& graphics_engine, bool force_draw)
{
graphics_engine.PushClippingRectangle(GetGeometry());
if (!IsFullRedraw() && RedirectedAncestor())
{
for (auto iter: filter_map_)
{
FilterExpanderLabel* filter_view = iter.second;
if (filter_view && filter_view->IsVisible() && filter_view->IsRedrawNeeded())
graphics::ClearGeometry(filter_view->GetGeometry());
}
}
GetLayout()->ProcessDraw(graphics_engine, force_draw);
graphics_engine.PopClippingRectangle();
}
virtual void Draw(nux::GraphicsEngine& gfx_engine, bool force_draw)
{
nux::Geometry const& base = GetGeometry();
gfx_engine.PushClippingRectangle(base);
nux::GetPainter().PaintBackground(gfx_engine, base);
unsigned int alpha, src, dest = 0;
gfx_engine.GetRenderStates().GetBlend(alpha, src, dest);
gfx_engine.GetRenderStates().SetBlend(true, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
bg_layer_->SetGeometry(GetGeometry());
nux::GetPainter().RenderSinglePaintLayer(gfx_engine, GetGeometry(), bg_layer_.get());
gfx_engine.GetRenderStates().SetBlend(alpha, src, dest);
gfx_engine.PopClippingRectangle();
}
void FilterExpanderLabel::DrawContent(nux::GraphicsEngine& graphics_engine, bool force_draw)
{
graphics_engine.PushClippingRectangle(GetGeometry());
int pushed_paint_layers = 0;
if (!IsFullRedraw())
{
if (RedirectedAncestor())
{
if (cairo_label_->IsRedrawNeeded())
graphics::ClearGeometry(cairo_label_->GetGeometry());
if (expand_icon_->IsRedrawNeeded())
graphics::ClearGeometry(expand_icon_->GetGeometry());
if (right_hand_contents_ && right_hand_contents_->IsRedrawNeeded())
graphics::ClearGeometry(right_hand_contents_->GetGeometry());
if (expanded())
ClearRedirectedRenderChildArea();
}
if (focus_layer_ && ShouldBeHighlighted())
{
++pushed_paint_layers;
nux::GetPainter().PushLayer(graphics_engine, focus_layer_->GetGeometry(), focus_layer_.get());
}
}
else
{
nux::GetPainter().PushPaintLayerStack();
}
GetLayout()->ProcessDraw(graphics_engine, force_draw);
if (IsFullRedraw())
{
nux::GetPainter().PopPaintLayerStack();
}
else if (pushed_paint_layers > 0)
{
nux::GetPainter().PopBackground(pushed_paint_layers);
}
graphics_engine.PopClippingRectangle();
}
void UserPromptView::DrawContent(nux::GraphicsEngine& graphics_engine, bool force_draw)
{
nux::Geometry const& geo = GetGeometry();
graphics_engine.PushClippingRectangle(geo);
if (!IsFullRedraw())
{
EnsureBGLayer();
nux::GetPainter().PushLayer(graphics_engine, geo, bg_layer_.get());
}
if (GetLayout())
GetLayout()->ProcessDraw(graphics_engine, force_draw);
if (!IsFullRedraw())
nux::GetPainter().PopBackground();
graphics_engine.PopClippingRectangle();
}
void FilterExpanderLabel::Draw(nux::GraphicsEngine& graphics_engine, bool force_draw)
{
nux::Geometry const& base = GetGeometry();
graphics_engine.PushClippingRectangle(base);
if (ShouldBeHighlighted())
{
nux::Geometry geo(top_bar_layout_->GetGeometry());
geo.x = base.x;
geo.width = base.width;
if (!focus_layer_)
focus_layer_.reset(dash::Style::Instance().FocusOverlay(geo.width, geo.height));
focus_layer_->SetGeometry(geo);
focus_layer_->Renderlayer(graphics_engine);
}
graphics_engine.PopClippingRectangle();
}
void PaymentPreview::Draw(nux::GraphicsEngine& gfx_engine, bool force_draw)
{
nux::Geometry const& base = GetGeometry();
gfx_engine.PushClippingRectangle(base);
nux::GetPainter().PaintBackground(gfx_engine, base);
if (full_data_layout_)
{
unsigned int alpha, src, dest = 0;
gfx_engine.GetRenderStates().GetBlend(alpha, src, dest);
gfx_engine.GetRenderStates().SetBlend(true, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
details_bg_layer_->SetGeometry(full_data_layout_->GetGeometry());
nux::GetPainter().RenderSinglePaintLayer(gfx_engine, full_data_layout_->GetGeometry(), details_bg_layer_.get());
gfx_engine.GetRenderStates().SetBlend(alpha, src, dest);
}
gfx_engine.PopClippingRectangle();
}
void HudButton::Draw(nux::GraphicsEngine& GfxContext, bool force_draw)
{
if (skip_draw_)
return;
nux::Geometry const& geo = GetGeometry();
GfxContext.PushClippingRectangle(geo);
gPainter.PaintBackground(GfxContext, geo);
// set up our texture mode
nux::TexCoordXForm texxform;
texxform.SetWrap(nux::TEXWRAP_CLAMP, nux::TEXWRAP_CLAMP);
texxform.SetTexCoordType(nux::TexCoordXForm::OFFSET_COORD);
// clear what is behind us
unsigned int alpha = 0, src = 0, dest = 0;
GfxContext.GetRenderStates().GetBlend(alpha, src, dest);
GfxContext.GetRenderStates().SetPremultipliedBlend(nux::SRC_OVER);
GfxContext.GetRenderStates().SetBlend(true);
nux::Color col(nux::color::Black);
col.alpha = 0;
GfxContext.QRP_Color(geo.x,
geo.y,
geo.width,
geo.height,
col);
nux::BaseTexture* texture = normal_->GetTexture();
if (HasKeyFocus() || fake_focused())
texture = active_->GetTexture();
else if (HasKeyFocus())
texture = prelight_->GetTexture();
else if (GetVisualState() == nux::ButtonVisualState::VISUAL_STATE_PRESSED)
texture = active_->GetTexture();
GfxContext.QRP_1Tex(geo.x,
geo.y,
texture->GetWidth(),
texture->GetHeight(),
texture->GetDeviceTexture(),
texxform,
nux::color::White);
GfxContext.GetRenderStates().SetBlend(alpha, src, dest);
GfxContext.PopClippingRectangle();
}
void PaymentPreview::DrawContent(nux::GraphicsEngine& gfx_engine, bool force_draw)
{
nux::Geometry const& base = GetGeometry();
gfx_engine.PushClippingRectangle(base);
if (!IsFullRedraw())
nux::GetPainter().PushLayer(gfx_engine, details_bg_layer_->GetGeometry(), details_bg_layer_.get());
unsigned int alpha, src, dest = 0;
gfx_engine.GetRenderStates().GetBlend(alpha, src, dest);
gfx_engine.GetRenderStates().SetBlend(true, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
if (GetCompositionLayout())
GetCompositionLayout()->ProcessDraw(gfx_engine, force_draw);
gfx_engine.GetRenderStates().SetBlend(alpha, src, dest);
if (!IsFullRedraw())
nux::GetPainter().PopBackground();
gfx_engine.PopClippingRectangle();
}
void VScrollBarOverlayWindow::Draw(nux::GraphicsEngine& graphics_engine, bool force_draw)
{
if (!thumb_texture_)
return;
nux::Geometry base(0, mouse_offset_y_, THUMB_WIDTH.CP(scale), THUMB_HEIGHT.CP(scale));
nux::TexCoordXForm texxform;
graphics_engine.QRP_1Tex(base.x,
base.y,
base.width,
base.height,
thumb_texture_->GetDeviceTexture(),
texxform,
nux::color::White);
}
void ScopeBarIcon::Draw(nux::GraphicsEngine& graphics_engine, bool force_draw)
{
nux::Geometry const& geo = GetGeometry();
graphics_engine.PushClippingRectangle(geo);
if (HasKeyFocus() && focus_layer_)
{
nux::Geometry geo(GetGeometry());
nux::AbstractPaintLayer* layer = focus_layer_.get();
layer->SetGeometry(geo);
layer->Renderlayer(graphics_engine);
}
if (texture())
{
unsigned int current_alpha_blend;
unsigned int current_src_blend_factor;
unsigned int current_dest_blend_factor;
graphics_engine.GetRenderStates().GetBlend(current_alpha_blend, current_src_blend_factor, current_dest_blend_factor);
graphics_engine.GetRenderStates().SetBlend(true, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
float opacity = active ? 1.0f : inactive_opacity_;
int width = 0, height = 0;
GetTextureSize(&width, &height);
nux::TexCoordXForm texxform;
texxform.SetTexCoordType(nux::TexCoordXForm::OFFSET_COORD);
texxform.SetWrap(nux::TEXWRAP_CLAMP_TO_BORDER, nux::TEXWRAP_CLAMP_TO_BORDER);
graphics_engine.QRP_1Tex(geo.x + ((geo.width - width) / 2),
geo.y + ((geo.height - height) / 2),
width,
height,
texture()->GetDeviceTexture(),
texxform,
nux::color::White * opacity);
graphics_engine.GetRenderStates().SetBlend(current_alpha_blend, current_src_blend_factor, current_dest_blend_factor);
}
graphics_engine.PopClippingRectangle();
}
void
PlacesVScrollBar::DrawScrollbar(nux::GraphicsEngine& graphics_engine)
{
// check if textures have been computed... if they haven't, exit function
if (!slider_texture_)
return;
nux::Color color = nux::color::White;
nux::Geometry const& base = GetGeometry();
nux::TexCoordXForm texxform;
graphics_engine.PushClippingRectangle(base);
unsigned int alpha = 0, src = 0, dest = 0;
graphics_engine.GetRenderStates().GetBlend(alpha, src, dest);
texxform.SetTexCoordType(nux::TexCoordXForm::OFFSET_SCALE_COORD);
graphics_engine.GetRenderStates().SetBlend(true);
graphics_engine.GetRenderStates().SetPremultipliedBlend(nux::SRC_OVER);
if (content_height_ > container_height_)
{
nux::Geometry const& slider_geo = _slider->GetGeometry();
graphics_engine.QRP_1Tex(slider_geo.x,
slider_geo.y,
slider_geo.width,
slider_geo.height,
slider_texture_->GetDeviceTexture(),
texxform,
color);
}
graphics_engine.PopClippingRectangle();
graphics_engine.GetRenderStates().SetBlend(alpha, src, dest);
}
void RatingsButton::Draw(nux::GraphicsEngine& GfxContext, bool force_draw)
{
int rating = static_cast<int>(GetRating() * NUM_STARS);
// FIXME: 9/26/2011
// We should probably support an API for saying whether the ratings
// should or shouldn't support half stars...but our only consumer at
// the moment is the applications scope which according to design
// (Bug #839759) shouldn't. So for now just force rounding.
// int total_half_stars = rating % 2;
// int total_full_stars = rating / 2;
int total_full_stars = rating;
nux::Geometry const& geo = GetGeometry();
nux::Geometry geo_star(geo);
geo_star.width = star_size_.CP(scale);
geo_star.height = star_size_.CP(scale);
gPainter.PaintBackground(GfxContext, geo);
// set up our texture mode
nux::TexCoordXForm texxform;
texxform.SetWrap(nux::TEXWRAP_CLAMP_TO_BORDER, nux::TEXWRAP_CLAMP_TO_BORDER);
texxform.SetTexCoordType(nux::TexCoordXForm::OFFSET_SCALE_COORD);
texxform.SetFilter(nux::TEXFILTER_LINEAR, nux::TEXFILTER_LINEAR);
// clear what is behind us
unsigned int alpha = 0, src = 0, dest = 0;
GfxContext.GetRenderStates().GetBlend(alpha, src, dest);
GfxContext.GetRenderStates().SetBlend(true, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
nux::Color col = nux::color::Black;
col.alpha = 0;
GfxContext.QRP_Color(geo.x,
geo.y,
geo.width,
geo.height,
col);
for (int index = 0; index < NUM_STARS; ++index)
{
dash::Style& style = dash::Style::Instance();
auto texture = style.GetStarSelectedIcon();
if (index < total_full_stars)
{
if (GetVisualState() == nux::ButtonVisualState::VISUAL_STATE_NORMAL)
texture = style.GetStarSelectedIcon();
else if (GetVisualState() == nux::ButtonVisualState::VISUAL_STATE_PRELIGHT)
texture = style.GetStarSelectedIcon();
else if (GetVisualState() == nux::ButtonVisualState::VISUAL_STATE_PRESSED)
texture = style.GetStarSelectedIcon();
}
else
{
if (GetVisualState() == nux::ButtonVisualState::VISUAL_STATE_NORMAL)
texture = style.GetStarDeselectedIcon();
else if (GetVisualState() == nux::ButtonVisualState::VISUAL_STATE_PRELIGHT)
texture = style.GetStarDeselectedIcon();
else if (GetVisualState() == nux::ButtonVisualState::VISUAL_STATE_PRESSED)
texture = style.GetStarDeselectedIcon();
}
GfxContext.QRP_1Tex(geo_star.x,
geo_star.y,
geo_star.width,
geo_star.height,
texture->GetDeviceTexture(),
texxform,
nux::Color(1.0f, 1.0f, 1.0f, 1.0f));
if (focused_star_ == index)
{
GfxContext.QRP_1Tex(geo_star.x,
geo_star.y,
geo_star.width,
geo_star.height,
style.GetStarHighlightIcon()->GetDeviceTexture(),
texxform,
nux::Color(1.0f, 1.0f, 1.0f, 0.5f));
}
geo_star.x += geo_star.width + star_gap_.CP(scale);
}
GfxContext.GetRenderStates().SetBlend(alpha, src, dest);
}
void IconTexture::Draw(nux::GraphicsEngine& GfxContext, bool force_draw)
{
unsigned int current_alpha_blend;
unsigned int current_src_blend_factor;
unsigned int current_dest_blend_factor;
GfxContext.GetRenderStates().GetBlend(current_alpha_blend, current_src_blend_factor, current_dest_blend_factor);
GfxContext.GetRenderStates().SetBlend(true, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
nux::Geometry geo = GetGeometry();
GfxContext.PushClippingRectangle(geo);
nux::GetPainter().PaintBackground(GfxContext, geo);
if (_texture_cached)
{
nux::Color col(1.0f * _opacity, 1.0f * _opacity, 1.0f * _opacity, _opacity);
nux::TexCoordXForm texxform;
if (_draw_mode == DrawMode::STRETCH_WITH_ASPECT)
{
nux::Geometry imageDest = geo;
float geo_apsect = float(geo.GetWidth()) / geo.GetHeight();
float image_aspect = float(_texture_cached->GetWidth()) / _texture_cached->GetHeight();
if (image_aspect > geo_apsect)
{
imageDest.SetHeight(float(imageDest.GetWidth()) / image_aspect);
}
if (image_aspect < geo_apsect)
{
imageDest.SetWidth(image_aspect * imageDest.GetHeight());
}
else
{
imageDest = nux::Geometry(0, 0, _texture_cached->GetWidth(), _texture_cached->GetHeight());
}
texxform.SetTexCoordType(nux::TexCoordXForm::OFFSET_SCALE_COORD);
texxform.SetWrap(nux::TEXWRAP_CLAMP_TO_BORDER, nux::TEXWRAP_CLAMP_TO_BORDER);
texxform.SetFilter(nux::TEXFILTER_LINEAR, nux::TEXFILTER_LINEAR);
texxform.u0 = 0;
texxform.v0 = 0;
texxform.u1 = imageDest.width;
texxform.v1 = imageDest.height;
int border_width = 1;
GfxContext.QRP_1Tex(geo.x + (float(geo.GetWidth() - imageDest.GetWidth()) / 2) + border_width,
geo.y + (float(geo.GetHeight() - imageDest.GetHeight()) / 2) + border_width,
imageDest.width - (border_width * 2),
imageDest.height - (border_width * 2),
_texture_cached.GetPointer()->GetDeviceTexture(),
texxform,
col);
}
else
{
texxform.SetTexCoordType(nux::TexCoordXForm::OFFSET_COORD);
texxform.SetWrap(nux::TEXWRAP_CLAMP_TO_BORDER, nux::TEXWRAP_CLAMP_TO_BORDER);
GfxContext.QRP_1Tex(geo.x + ((geo.width - _texture_size.width) / 2),
geo.y + ((geo.height - _texture_size.height) / 2),
_texture_size.width,
_texture_size.height,
_texture_cached->GetDeviceTexture(),
texxform,
col);
}
}
GfxContext.PopClippingRectangle();
GfxContext.GetRenderStates().SetBlend(current_alpha_blend, current_src_blend_factor, current_dest_blend_factor);
}
void
PanelView::Draw(nux::GraphicsEngine& GfxContext, bool force_draw)
{
nux::Geometry const& geo = GetGeometry();
UpdateBackground();
bool overlay_mode = InOverlayMode();
GfxContext.PushClippingRectangle(geo);
if (IsTransparent())
{
nux::Geometry const& geo_absolute = GetAbsoluteGeometry();
if (BackgroundEffectHelper::blur_type != BLUR_NONE)
{
bg_blur_texture_ = bg_effect_helper_.GetBlurRegion();
}
else
{
bg_blur_texture_ = bg_effect_helper_.GetRegion();
}
if (bg_blur_texture_.IsValid())
{
nux::TexCoordXForm texxform_blur_bg;
texxform_blur_bg.flip_v_coord = true;
texxform_blur_bg.SetTexCoordType(nux::TexCoordXForm::OFFSET_COORD);
texxform_blur_bg.uoffset = geo.x / static_cast<float>(geo_absolute.width);
texxform_blur_bg.voffset = geo.y / static_cast<float>(geo_absolute.height);
nux::ROPConfig rop;
rop.Blend = false;
rop.SrcBlend = GL_ONE;
rop.DstBlend = GL_ONE_MINUS_SRC_ALPHA;
GfxContext.PushClippingRectangle(geo);
#ifndef NUX_OPENGLES_20
if (GfxContext.UsingGLSLCodePath())
gPainter.PushDrawCompositionLayer(GfxContext, geo,
bg_blur_texture_,
texxform_blur_bg,
nux::color::White,
WindowManager::Default().average_color(),
nux::LAYER_BLEND_MODE_OVERLAY,
true, rop);
else
gPainter.PushDrawTextureLayer(GfxContext, geo,
bg_blur_texture_,
texxform_blur_bg,
nux::color::White,
true,
rop);
#else
gPainter.PushDrawCompositionLayer(GfxContext, geo,
bg_blur_texture_,
texxform_blur_bg,
nux::color::White,
WindowManager::Default().average_color(),
nux::LAYER_BLEND_MODE_OVERLAY,
true, rop);
#endif
GfxContext.PopClippingRectangle();
}
if (overlay_mode && !Settings::Instance().GetLowGfxMode())
{
nux::GetPainter().RenderSinglePaintLayer(GfxContext, geo, bg_darken_layer_.get());
GfxContext.GetRenderStates().SetBlend(true, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
nux::TexCoordXForm refine_texxform;
int refine_x_pos = geo.x + (stored_dash_width_ - refine_gradient_midpoint);
refine_x_pos += unity::Settings::Instance().LauncherWidth(monitor_);
GfxContext.QRP_1Tex(refine_x_pos, geo.y,
bg_refine_tex_->GetWidth(),
bg_refine_tex_->GetHeight(),
bg_refine_tex_->GetDeviceTexture(),
refine_texxform, nux::color::White);
GfxContext.QRP_1Tex(refine_x_pos + bg_refine_tex_->GetWidth(),
geo.y, geo.width, geo.height,
bg_refine_single_column_tex_->GetDeviceTexture(),
refine_texxform, nux::color::White);
}
}
if (!overlay_mode || !GfxContext.UsingGLSLCodePath())
nux::GetPainter().RenderSinglePaintLayer(GfxContext, geo, bg_layer_.get());
GfxContext.PopClippingRectangle();
if (needs_geo_sync_)
{
SyncGeometries();
needs_geo_sync_ = false;
}
}
void
PanelView::DrawContent(nux::GraphicsEngine& GfxContext, bool force_draw)
{
nux::Geometry const& geo = GetGeometry();
bool overlay_mode = InOverlayMode();
int bgs = 1;
GfxContext.PushClippingRectangle(geo);
GfxContext.GetRenderStates().SetBlend(true);
GfxContext.GetRenderStates().SetPremultipliedBlend(nux::SRC_OVER);
if (bg_blur_texture_.IsValid() && IsTransparent())
{
nux::Geometry const& geo_absolute = GetAbsoluteGeometry();
nux::TexCoordXForm texxform_blur_bg;
texxform_blur_bg.flip_v_coord = true;
texxform_blur_bg.SetTexCoordType(nux::TexCoordXForm::OFFSET_COORD);
texxform_blur_bg.uoffset = geo.x / static_cast<float>(geo_absolute.width);
texxform_blur_bg.voffset = geo.y / static_cast<float>(geo_absolute.height);
nux::ROPConfig rop;
rop.Blend = false;
rop.SrcBlend = GL_ONE;
rop.DstBlend = GL_ONE_MINUS_SRC_ALPHA;
#ifndef NUX_OPENGLES_20
if (GfxContext.UsingGLSLCodePath())
gPainter.PushCompositionLayer(GfxContext, geo,
bg_blur_texture_,
texxform_blur_bg,
nux::color::White,
WindowManager::Default().average_color(),
nux::LAYER_BLEND_MODE_OVERLAY,
true,
rop);
else
gPainter.PushTextureLayer(GfxContext, geo,
bg_blur_texture_,
texxform_blur_bg,
nux::color::White,
true,
rop);
#else
gPainter.PushCompositionLayer(GfxContext, geo,
bg_blur_texture_,
texxform_blur_bg,
nux::color::White,
WindowManager::Default().average_color(),
nux::LAYER_BLEND_MODE_OVERLAY,
true,
rop);
#endif
bgs++;
if (overlay_mode)
{
if (Settings::Instance().GetLowGfxMode())
{
rop.Blend = false;
auto const& bg_color = WindowManager::Default().average_color();
bg_darken_layer_.reset(new nux::ColorLayer(bg_color, false, rop));
}
nux::GetPainter().PushLayer(GfxContext, geo, bg_darken_layer_.get());
bgs++;
nux::Geometry refine_geo = geo;
int refine_x_pos = geo.x + (stored_dash_width_ - refine_gradient_midpoint);
refine_x_pos += unity::Settings::Instance().LauncherWidth(monitor_);
refine_geo.x = refine_x_pos;
refine_geo.width = bg_refine_tex_->GetWidth();
if (!Settings::Instance().GetLowGfxMode())
{
nux::GetPainter().PushLayer(GfxContext, refine_geo, bg_refine_layer_.get());
bgs++;
refine_geo.x += refine_geo.width;
refine_geo.width = geo.width;
nux::GetPainter().PushLayer(GfxContext, refine_geo, bg_refine_single_column_layer_.get());
bgs++;
}
}
}
if (!overlay_mode || !GfxContext.UsingGLSLCodePath())
gPainter.PushLayer(GfxContext, geo, bg_layer_.get());
if (overlay_mode && !Settings::Instance().GetLowGfxMode())
{
// apply the shine
nux::TexCoordXForm texxform;
texxform.SetTexCoordType(nux::TexCoordXForm::OFFSET_COORD);
texxform.SetWrap(nux::TEXWRAP_CLAMP, nux::TEXWRAP_CLAMP);
nux::ROPConfig rop;
rop.Blend = true;
rop.SrcBlend = GL_DST_COLOR;
rop.DstBlend = GL_ONE;
nux::GetPainter().PushTextureLayer(GfxContext, geo,
panel_sheen_->GetDeviceTexture(),
texxform,
nux::color::White,
false,
rop);
}
layout_->ProcessDraw(GfxContext, force_draw);
gPainter.PopBackground(bgs);
GfxContext.GetRenderStates().SetBlend(false);
GfxContext.PopClippingRectangle();
}
