void NonShinyLookAndFeel::drawLinearSlider (Graphics& g,
int x, int y,
int width, int height,
float sliderPos,
float minSliderPos,
float maxSliderPos,
const Slider::SliderStyle style,
Slider& slider)
{
g.fillAll (slider.findColour (Slider::backgroundColourId));
if (style == Slider::LinearBar)
{
const bool isMouseOver = slider.isMouseOverOrDragging() && slider.isEnabled();
Colour baseColour (createBaseColour (slider.findColour (Slider::thumbColourId)
.withMultipliedSaturation (slider.isEnabled() ? 1.0f : 0.5f),
false,
isMouseOver,
isMouseOver || slider.isMouseButtonDown()));
drawShinyButtonShape (g,
(float) x, (float) y, sliderPos - (float) x, (float) height, 0.0f,
baseColour,
slider.isEnabled() ? 0.9f : 0.3f,
true, true, true, true);
}
else
{
drawLinearSliderBackground (g, x, y, width, height, sliderPos, minSliderPos, maxSliderPos, style, slider);
drawLinearSliderThumb (g, x, y, width, height, sliderPos, minSliderPos, maxSliderPos, style, slider);
}
}
void NonShinyLookAndFeel::drawTickBox (Graphics& g,
Component& component,
float x, float y, float w, float h,
const bool ticked,
const bool isEnabled,
const bool isMouseOverButton,
const bool isButtonDown)
{
const float boxSize = w * 0.8f;
drawGlassLozenge (g,x,y+(h-boxSize)*0.5f,boxSize,boxSize,
createBaseColour (component.findColour (TextButton::buttonColourId)
.withMultipliedAlpha (isEnabled ? 1.0f : 0.5f),
true,
isMouseOverButton,
isButtonDown),
isEnabled ? ((isButtonDown || isMouseOverButton) ? 1.2f : 0.7f) : 0.4f,
-1.0f,true,true,true,true);
if (ticked)
{
Path tick;
tick.startNewSubPath (2.0f, 3.0f);
tick.lineTo (3.5f, 6.0f);
tick.lineTo (6.5f, 0.0f);
g.setColour (isEnabled ? Colours::black : Colours::grey);
const AffineTransform trans (AffineTransform::scale (w / 9.0f, h / 9.0f)
.translated (x, y));
g.strokePath (tick, PathStrokeType (2.5f), trans);
}
}
//==============================================================================
void NonShinyLookAndFeel::drawButtonBackground (Graphics& g,
Button& button,
const Colour& backgroundColour,
bool isMouseOverButton,
bool isButtonDown)
{
const int width = button.getWidth();
const int height = button.getHeight();
const float outlineThickness = button.isEnabled() ? ((isButtonDown || isMouseOverButton) ? 1.2f : 0.7f) : 0.4f;
const float halfThickness = outlineThickness * 0.5f;
const float indentL = button.isConnectedOnLeft() ? 0.1f : halfThickness;
const float indentR = button.isConnectedOnRight() ? 0.1f : halfThickness;
const float indentT = button.isConnectedOnTop() ? 0.1f : halfThickness;
const float indentB = button.isConnectedOnBottom() ? (button.getToggleState() ? -1.f : 0.1f) : halfThickness;
const Colour baseColour (createBaseColour (backgroundColour,
button.hasKeyboardFocus (true),
isMouseOverButton, isButtonDown)
.withMultipliedAlpha (button.isEnabled() ? 1.0f : 0.5f));
drawGlassLozenge (g,
indentL,
indentT,
width - indentL - indentR,
height - indentT - indentB,
baseColour, outlineThickness, -1.0f,
button.isConnectedOnLeft(),
button.isConnectedOnRight(),
button.isConnectedOnTop(),
button.isConnectedOnBottom());
}
//==============================================================================
void NonShinyLookAndFeel::drawComboBox (Graphics& g, int width, int height,
const bool isButtonDown,
int buttonX, int buttonY,
int buttonW, int buttonH,
ComboBox& box)
{
g.fillAll (box.findColour (ComboBox::backgroundColourId));
if (box.isEnabled() && box.hasKeyboardFocus (false))
{
g.setColour (box.findColour (TextButton::buttonColourId));
g.drawRect (0, 0, width, height, 2);
}
else
{
g.setColour (box.findColour (ComboBox::outlineColourId));
g.drawRect (0, 0, width, height);
}
const float outlineThickness = box.isEnabled() ? (isButtonDown ? 1.2f : 0.7f) : 0.4f;
const Colour baseColour (createBaseColour (box.findColour (ComboBox::buttonColourId),
box.hasKeyboardFocus (true),
false, isButtonDown)
.withMultipliedAlpha (box.isEnabled() ? 1.0f : 0.5f));
drawGlassLozenge (g,
buttonX + outlineThickness, buttonY + outlineThickness,
buttonW - outlineThickness * 2.0f, buttonH - outlineThickness * 2.0f,
baseColour, outlineThickness, -1.0f,
true, true, true, true);
if (box.isEnabled())
{
const float arrowX = 0.3f;
const float arrowH = 0.2f;
Path p;
//p.addTriangle (buttonX + buttonW * 0.5f, buttonY + buttonH * (0.45f - arrowH),
// buttonX + buttonW * (1.0f - arrowX), buttonY + buttonH * 0.45f,
// buttonX + buttonW * arrowX, buttonY + buttonH * 0.45f);
p.addTriangle (buttonX + buttonW * 0.5f, buttonY + buttonH * (0.55f + arrowH),
buttonX + buttonW * (1.0f - arrowX), buttonY + buttonH * 0.55f,
buttonX + buttonW * arrowX, buttonY + buttonH * 0.55f);
g.setColour (box.findColour (ComboBox::arrowColourId));
g.fillPath (p);
}
}
void NonShinyLookAndFeel::drawMenuBarBackground (Graphics& g, int width, int height,
bool, MenuBarComponent& menuBar)
{
const Colour baseColour (createBaseColour (menuBar.findColour (PopupMenu::backgroundColourId), false, false, false));
if (menuBar.isEnabled())
{
drawShinyButtonShape (g,
-4.0f, 0.0f,
width + 8.0f, (float) height,
0.0f,
baseColour,
0.4f,
true, true, true, true);
}
else
{
g.fillAll (baseColour);
}
}
void TCATLookAndFeel::drawLinearSlider (Graphics& g,
int x, int y,
int width, int height,
float sliderPos,
float minSliderPos,
float maxSliderPos,
const Slider::SliderStyle style,
Slider& slider)
{
g.fillAll (slider.findColour (Slider::backgroundColourId));
const bool isMouseOver = slider.isMouseOverOrDragging() && slider.isEnabled();
if (style == Slider::LinearBar)
{
Colour baseColour (createBaseColour (slider.findColour (Slider::thumbColourId)
.withMultipliedSaturation (slider.isEnabled() ? 1.0f : 0.5f),
false,
isMouseOver, isMouseOver || slider.isMouseButtonDown()));
drawShinyButtonShape (g,
(float) x, (float) y, sliderPos - (float) x, (float) height, 0.0f,
baseColour,
slider.isEnabled() ? 0.9f : 0.3f,
true, true, true, true);
}
else
{
const float sliderRadius = (float) getSliderThumbRadius (slider);
const Colour trackColour (slider.findColour (Slider::trackColourId));
const Colour gradCol1 (trackColour.overlaidWith (Colours::black.withAlpha (slider.isEnabled() ? 0.25f : 0.13f)));
const Colour gradCol2 (trackColour.overlaidWith (Colours::black.withAlpha (0.08f)));
Path indent;
if (slider.isHorizontal())
{
const float iy = y + height * 0.5f - sliderRadius * 0.5f;
const float ih = sliderRadius;
ColourGradient cg (gradCol1, 0.0f, iy,
gradCol2, 0.0f, iy + ih, false);
g.setGradientFill(cg);
indent.addRoundedRectangle (x - sliderRadius * 0.5f, iy,
width + sliderRadius, ih,
5.0f);
g.fillPath (indent);
}
else
{
const float ix = x + width * 0.5f - sliderRadius * 0.5f;
const float iw = sliderRadius;
ColourGradient cg (gradCol1, ix, 0.0f,
gradCol2, ix + iw, 0.0f, false);
g.setGradientFill(cg);
indent.addRoundedRectangle (ix, y - sliderRadius * 0.5f,
iw, height + sliderRadius,
5.0f);
g.fillPath (indent);
}
g.setColour (Colours::black.withAlpha (0.3f));
g.strokePath (indent, PathStrokeType (0.5f));
Colour knobColour (createBaseColour (slider.findColour (Slider::thumbColourId),
slider.hasKeyboardFocus (false) && slider.isEnabled(),
isMouseOver,
slider.isMouseButtonDown() && slider.isEnabled()));
const float outlineThickness = slider.isEnabled() ? 0.8f : 0.3f;
if (style == Slider::LinearHorizontal || style == Slider::LinearVertical)
{
float kx, ky;
if (style == Slider::LinearVertical)
{
kx = x + width * 0.5f;
ky = sliderPos;
}
else
{
kx = sliderPos;
ky = y + height * 0.5f;
}
drawGlassSphere (g,
kx - sliderRadius,
ky - sliderRadius,
sliderRadius * 2.0f,
knobColour, outlineThickness);
}
else
{
if (style == Slider::ThreeValueVertical)
{
drawGlassSphere (g, x + width * 0.5f - sliderRadius,
sliderPos - sliderRadius,
sliderRadius * 2.0f,
knobColour, outlineThickness);
}
else if (style == Slider::ThreeValueHorizontal)
{
drawGlassSphere (g,sliderPos - sliderRadius,
y + height * 0.5f - sliderRadius,
sliderRadius * 2.0f,
knobColour, outlineThickness);
}
if (style == Slider::TwoValueVertical || style == Slider::ThreeValueVertical)
{
const float sr = jmin (sliderRadius, width * 0.4f);
drawGlassPointer (g, jmax (0.0f, x + width * 0.5f - sliderRadius * 2.0f),
minSliderPos - sliderRadius,
sliderRadius * 2.0f, knobColour, outlineThickness, 1);
drawGlassPointer (g, jmin (x + width - sliderRadius * 2.0f, x + width * 0.5f), maxSliderPos - sr,
sliderRadius * 2.0f, knobColour, outlineThickness, 3);
}
else if (style == Slider::TwoValueHorizontal || style == Slider::ThreeValueHorizontal)
{
const float sr = jmin (sliderRadius, height * 0.4f);
drawGlassPointer (g, minSliderPos - sr,
jmax (0.0f, y + height * 0.5f - sliderRadius * 2.0f),
sliderRadius * 2.0f, knobColour, outlineThickness, 2);
drawGlassPointer (g, maxSliderPos - sliderRadius,
jmin (y + height - sliderRadius * 2.0f, y + height * 0.5f),
sliderRadius * 2.0f, knobColour, outlineThickness, 4);
}
}
}
}
