allanger/paulxstretch
1
0
Fork 0
Code Issues 1 Pull Requests 1 Actions Packages Projects Releases 2 Activity

migrating to the latest JUCE version

Browse Source
This commit is contained in:
Nikolai Rodionov
2022-11-04 23:11:33 +01:00
committed by Nikolai Rodionov
parent 4257a0f8ba
commit faf8f18333
2796 changed files with 888518 additions and 784244 deletions
Download Patch File Download Diff File Expand all files Collapse all files

420
deps/juce/modules/juce_gui_basics/drawables/juce_Drawable.cpp vendored
View File

@ -1,201 +1,219 @@
/*
==============================================================================
This file is part of the JUCE library.
Copyright (c) 2020 - Raw Material Software Limited
JUCE is an open source library subject to commercial or open-source
licensing.
By using JUCE, you agree to the terms of both the JUCE 6 End-User License
Agreement and JUCE Privacy Policy (both effective as of the 16th June 2020).
End User License Agreement: www.juce.com/juce-6-licence
Privacy Policy: www.juce.com/juce-privacy-policy
Or: You may also use this code under the terms of the GPL v3 (see
www.gnu.org/licenses).
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
DISCLAIMED.
==============================================================================
*/
namespace juce
{
Drawable::Drawable()
{
setInterceptsMouseClicks (false, false);
setPaintingIsUnclipped (true);
setAccessible (false);
}
Drawable::Drawable (const Drawable& other)
: Component (other.getName())
{
setInterceptsMouseClicks (false, false);
setPaintingIsUnclipped (true);
setAccessible (false);
setComponentID (other.getComponentID());
setTransform (other.getTransform());
if (auto* clipPath = other.drawableClipPath.get())
setClipPath (clipPath->createCopy());
}
Drawable::~Drawable()
{
}
void Drawable::applyDrawableClipPath (Graphics& g)
{
if (drawableClipPath != nullptr)
{
auto clipPath = drawableClipPath->getOutlineAsPath();
if (! clipPath.isEmpty())
g.getInternalContext().clipToPath (clipPath, {});
}
}
//==============================================================================
void Drawable::draw (Graphics& g, float opacity, const AffineTransform& transform) const
{
const_cast<Drawable*> (this)->nonConstDraw (g, opacity, transform);
}
void Drawable::nonConstDraw (Graphics& g, float opacity, const AffineTransform& transform)
{
Graphics::ScopedSaveState ss (g);
g.addTransform (AffineTransform::translation ((float) -(originRelativeToComponent.x),
(float) -(originRelativeToComponent.y))
.followedBy (getTransform())
.followedBy (transform));
applyDrawableClipPath (g);
if (! g.isClipEmpty())
{
if (opacity < 1.0f)
{
g.beginTransparencyLayer (opacity);
paintEntireComponent (g, true);
g.endTransparencyLayer();
}
else
{
paintEntireComponent (g, true);
}
}
}
void Drawable::drawAt (Graphics& g, float x, float y, float opacity) const
{
draw (g, opacity, AffineTransform::translation (x, y));
}
void Drawable::drawWithin (Graphics& g, Rectangle<float> destArea,
RectanglePlacement placement, float opacity) const
{
draw (g, opacity, placement.getTransformToFit (getDrawableBounds(), destArea));
}
//==============================================================================
DrawableComposite* Drawable::getParent() const
{
return dynamic_cast<DrawableComposite*> (getParentComponent());
}
void Drawable::setClipPath (std::unique_ptr<Drawable> clipPath)
{
if (drawableClipPath != clipPath)
{
drawableClipPath = std::move (clipPath);
repaint();
}
}
void Drawable::transformContextToCorrectOrigin (Graphics& g)
{
g.setOrigin (originRelativeToComponent);
}
void Drawable::parentHierarchyChanged()
{
setBoundsToEnclose (getDrawableBounds());
}
void Drawable::setBoundsToEnclose (Rectangle<float> area)
{
Point<int> parentOrigin;
if (auto* parent = getParent())
parentOrigin = parent->originRelativeToComponent;
auto newBounds = area.getSmallestIntegerContainer() + parentOrigin;
originRelativeToComponent = parentOrigin - newBounds.getPosition();
setBounds (newBounds);
}
//==============================================================================
bool Drawable::replaceColour (Colour original, Colour replacement)
{
bool changed = false;
for (auto* c : getChildren())
if (auto* d = dynamic_cast<Drawable*> (c))
changed = d->replaceColour (original, replacement) || changed;
return changed;
}
//==============================================================================
void Drawable::setOriginWithOriginalSize (Point<float> originWithinParent)
{
setTransform (AffineTransform::translation (originWithinParent.x, originWithinParent.y));
}
void Drawable::setTransformToFit (const Rectangle<float>& area, RectanglePlacement placement)
{
if (! area.isEmpty())
setTransform (placement.getTransformToFit (getDrawableBounds(), area));
}
//==============================================================================
std::unique_ptr<Drawable> Drawable::createFromImageData (const void* data, const size_t numBytes)
{
auto image = ImageFileFormat::loadFrom (data, numBytes);
if (image.isValid())
return std::make_unique<DrawableImage> (image);
if (auto svg = parseXMLIfTagMatches (String::createStringFromData (data, (int) numBytes), "svg"))
return Drawable::createFromSVG (*svg);
return {};
}
std::unique_ptr<Drawable> Drawable::createFromImageDataStream (InputStream& dataSource)
{
MemoryOutputStream mo;
mo << dataSource;
return createFromImageData (mo.getData(), mo.getDataSize());
}
std::unique_ptr<Drawable> Drawable::createFromImageFile (const File& file)
{
FileInputStream fin (file);
if (fin.openedOk())
return createFromImageDataStream (fin);
return {};
}
} // namespace juce
/*
==============================================================================
This file is part of the JUCE library.
Copyright (c) 2022 - Raw Material Software Limited
JUCE is an open source library subject to commercial or open-source
licensing.
By using JUCE, you agree to the terms of both the JUCE 7 End-User License
Agreement and JUCE Privacy Policy.
End User License Agreement: www.juce.com/juce-7-licence
Privacy Policy: www.juce.com/juce-privacy-policy
Or: You may also use this code under the terms of the GPL v3 (see
www.gnu.org/licenses).
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
DISCLAIMED.
==============================================================================
*/
namespace juce
{
Drawable::Drawable()
{
setInterceptsMouseClicks (false, false);
setPaintingIsUnclipped (true);
setAccessible (false);
}
Drawable::Drawable (const Drawable& other)
: Component (other.getName())
{
setInterceptsMouseClicks (false, false);
setPaintingIsUnclipped (true);
setAccessible (false);
setComponentID (other.getComponentID());
setTransform (other.getTransform());
if (auto* clipPath = other.drawableClipPath.get())
setClipPath (clipPath->createCopy());
}
Drawable::~Drawable()
{
}
void Drawable::applyDrawableClipPath (Graphics& g)
{
if (drawableClipPath != nullptr)
{
auto clipPath = drawableClipPath->getOutlineAsPath();
if (! clipPath.isEmpty())
g.getInternalContext().clipToPath (clipPath, {});
}
}
//==============================================================================
void Drawable::draw (Graphics& g, float opacity, const AffineTransform& transform) const
{
const_cast<Drawable*> (this)->nonConstDraw (g, opacity, transform);
}
void Drawable::nonConstDraw (Graphics& g, float opacity, const AffineTransform& transform)
{
Graphics::ScopedSaveState ss (g);
g.addTransform (AffineTransform::translation ((float) -(originRelativeToComponent.x),
(float) -(originRelativeToComponent.y))
.followedBy (getTransform())
.followedBy (transform));
applyDrawableClipPath (g);
if (! g.isClipEmpty())
{
if (opacity < 1.0f)
{
g.beginTransparencyLayer (opacity);
paintEntireComponent (g, true);
g.endTransparencyLayer();
}
else
{
paintEntireComponent (g, true);
}
}
}
void Drawable::drawAt (Graphics& g, float x, float y, float opacity) const
{
draw (g, opacity, AffineTransform::translation (x, y));
}
void Drawable::drawWithin (Graphics& g, Rectangle<float> destArea,
RectanglePlacement placement, float opacity) const
{
draw (g, opacity, placement.getTransformToFit (getDrawableBounds(), destArea));
}
//==============================================================================
DrawableComposite* Drawable::getParent() const
{
return dynamic_cast<DrawableComposite*> (getParentComponent());
}
void Drawable::setClipPath (std::unique_ptr<Drawable> clipPath)
{
if (drawableClipPath != clipPath)
{
drawableClipPath = std::move (clipPath);
repaint();
}
}
void Drawable::transformContextToCorrectOrigin (Graphics& g)
{
g.setOrigin (originRelativeToComponent);
}
void Drawable::parentHierarchyChanged()
{
setBoundsToEnclose (getDrawableBounds());
}
void Drawable::setBoundsToEnclose (Rectangle<float> area)
{
Point<int> parentOrigin;
if (auto* parent = getParent())
parentOrigin = parent->originRelativeToComponent;
auto newBounds = area.getSmallestIntegerContainer() + parentOrigin;
originRelativeToComponent = parentOrigin - newBounds.getPosition();
setBounds (newBounds);
updateTransform();
}
//==============================================================================
bool Drawable::replaceColour (Colour original, Colour replacement)
{
bool changed = false;
for (auto* c : getChildren())
if (auto* d = dynamic_cast<Drawable*> (c))
changed = d->replaceColour (original, replacement) || changed;
return changed;
}
void Drawable::setDrawableTransform (const AffineTransform& transform)
{
drawableTransform = transform;
updateTransform();
}
void Drawable::updateTransform()
{
if (drawableTransform.isIdentity())
return;
const auto transformationOrigin = originRelativeToComponent + getPosition();
setTransform (AffineTransform::translation (transformationOrigin * (-1))
.followedBy (drawableTransform)
.followedBy (AffineTransform::translation (transformationOrigin)));
}
//==============================================================================
void Drawable::setOriginWithOriginalSize (Point<float> originWithinParent)
{
setTransform (AffineTransform::translation (originWithinParent.x, originWithinParent.y));
}
void Drawable::setTransformToFit (const Rectangle<float>& area, RectanglePlacement placement)
{
if (! area.isEmpty())
setTransform (placement.getTransformToFit (getDrawableBounds(), area));
}
//==============================================================================
std::unique_ptr<Drawable> Drawable::createFromImageData (const void* data, const size_t numBytes)
{
auto image = ImageFileFormat::loadFrom (data, numBytes);
if (image.isValid())
return std::make_unique<DrawableImage> (image);
if (auto svg = parseXMLIfTagMatches (String::createStringFromData (data, (int) numBytes), "svg"))
return Drawable::createFromSVG (*svg);
return {};
}
std::unique_ptr<Drawable> Drawable::createFromImageDataStream (InputStream& dataSource)
{
MemoryOutputStream mo;
mo << dataSource;
return createFromImageData (mo.getData(), mo.getDataSize());
}
std::unique_ptr<Drawable> Drawable::createFromImageFile (const File& file)
{
FileInputStream fin (file);
if (fin.openedOk())
return createFromImageDataStream (fin);
return {};
}
} // namespace juce

443
deps/juce/modules/juce_gui_basics/drawables/juce_Drawable.h vendored
View File

@ -1,213 +1,230 @@
/*
==============================================================================
This file is part of the JUCE library.
Copyright (c) 2020 - Raw Material Software Limited
JUCE is an open source library subject to commercial or open-source
licensing.
By using JUCE, you agree to the terms of both the JUCE 6 End-User License
Agreement and JUCE Privacy Policy (both effective as of the 16th June 2020).
End User License Agreement: www.juce.com/juce-6-licence
Privacy Policy: www.juce.com/juce-privacy-policy
Or: You may also use this code under the terms of the GPL v3 (see
www.gnu.org/licenses).
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
DISCLAIMED.
==============================================================================
*/
namespace juce
{
//==============================================================================
/**
The base class for objects which can draw themselves, e.g. polygons, images, etc.
@see DrawableComposite, DrawableImage, DrawablePath, DrawableText
@tags{GUI}
*/
class JUCE_API Drawable : public Component
{
protected:
//==============================================================================
/** The base class can't be instantiated directly.
@see DrawableComposite, DrawableImage, DrawablePath, DrawableText
*/
Drawable();
public:
/** Destructor. */
~Drawable() override;
//==============================================================================
/** Creates a deep copy of this Drawable object.
Use this to create a new copy of this and any sub-objects in the tree.
*/
virtual std::unique_ptr<Drawable> createCopy() const = 0;
/** Creates a path that describes the outline of this drawable. */
virtual Path getOutlineAsPath() const = 0;
//==============================================================================
/** Renders this Drawable object.
Note that the preferred way to render a drawable in future is by using it
as a component and adding it to a parent, so you might want to consider that
before using this method.
@see drawWithin
*/
void draw (Graphics& g, float opacity,
const AffineTransform& transform = AffineTransform()) const;
/** Renders the Drawable at a given offset within the Graphics context.
The coordinates passed-in are used to translate the object relative to its own
origin before drawing it - this is basically a quick way of saying:
@code
draw (g, AffineTransform::translation (x, y)).
@endcode
Note that the preferred way to render a drawable in future is by using it
as a component and adding it to a parent, so you might want to consider that
before using this method.
*/
void drawAt (Graphics& g, float x, float y, float opacity) const;
/** Renders the Drawable within a rectangle, scaling it to fit neatly inside without
changing its aspect-ratio.
The object can placed arbitrarily within the rectangle based on a Justification type,
and can either be made as big as possible, or just reduced to fit.
Note that the preferred way to render a drawable in future is by using it
as a component and adding it to a parent, so you might want to consider that
before using this method.
@param g the graphics context to render onto
@param destArea the target rectangle to fit the drawable into
@param placement defines the alignment and rescaling to use to fit
this object within the target rectangle.
@param opacity the opacity to use, in the range 0 to 1.0
*/
void drawWithin (Graphics& g,
Rectangle<float> destArea,
RectanglePlacement placement,
float opacity) const;
//==============================================================================
/** Resets any transformations on this drawable, and positions its origin within
its parent component.
*/
void setOriginWithOriginalSize (Point<float> originWithinParent);
/** Sets a transform for this drawable that will position it within the specified
area of its parent component.
*/
void setTransformToFit (const Rectangle<float>& areaInParent, RectanglePlacement placement);
/** Returns the DrawableComposite that contains this object, if there is one. */
DrawableComposite* getParent() const;
/** Sets a the clipping region of this drawable using another drawable.
The drawable passed in will be deleted when no longer needed.
*/
void setClipPath (std::unique_ptr<Drawable> drawableClipPath);
//==============================================================================
/** Tries to turn some kind of image file into a drawable.
The data could be an image that the ImageFileFormat class understands, or it
could be SVG.
*/
static std::unique_ptr<Drawable> createFromImageData (const void* data, size_t numBytes);
/** Tries to turn a stream containing some kind of image data into a drawable.
The data could be an image that the ImageFileFormat class understands, or it
could be SVG.
*/
static std::unique_ptr<Drawable> createFromImageDataStream (InputStream& dataSource);
/** Tries to turn a file containing some kind of image data into a drawable.
The data could be an image that the ImageFileFormat class understands, or it
could be SVG.
*/
static std::unique_ptr<Drawable> createFromImageFile (const File& file);
/** Attempts to parse an SVG (Scalable Vector Graphics) document, and to turn this
into a Drawable tree.
If something goes wrong while parsing, it may return nullptr.
SVG is a pretty large and complex spec, and this doesn't aim to be a full
implementation, but it can return the basic vector objects.
*/
static std::unique_ptr<Drawable> createFromSVG (const XmlElement& svgDocument);
/** Attempts to parse an SVG (Scalable Vector Graphics) document from a file,
and to turn this into a Drawable tree.
If something goes wrong while parsing, it may return nullptr.
SVG is a pretty large and complex spec, and this doesn't aim to be a full
implementation, but it can return the basic vector objects.
Any references to references to external image files will be relative to
the parent directory of the file passed.
*/
static std::unique_ptr<Drawable> createFromSVGFile (const File& svgFile);
/** Parses an SVG path string and returns it. */
static Path parseSVGPath (const String& svgPath);
//==============================================================================
/** Returns the area that this drawable covers.
The result is expressed in this drawable's own coordinate space, and does not take
into account any transforms that may be applied to the component.
*/
virtual Rectangle<float> getDrawableBounds() const = 0;
/** Recursively replaces a colour that might be used for filling or stroking.
return true if any instances of this colour were found.
*/
virtual bool replaceColour (Colour originalColour, Colour replacementColour);
protected:
//==============================================================================
friend class DrawableComposite;
friend class DrawableShape;
/** @internal */
void transformContextToCorrectOrigin (Graphics&);
/** @internal */
void parentHierarchyChanged() override;
/** @internal */
void setBoundsToEnclose (Rectangle<float>);
/** @internal */
void applyDrawableClipPath (Graphics&);
Point<int> originRelativeToComponent;
std::unique_ptr<Drawable> drawableClipPath;
void nonConstDraw (Graphics&, float opacity, const AffineTransform&);
Drawable (const Drawable&);
Drawable& operator= (const Drawable&);
JUCE_LEAK_DETECTOR (Drawable)
};
} // namespace juce
/*
==============================================================================
This file is part of the JUCE library.
Copyright (c) 2022 - Raw Material Software Limited
JUCE is an open source library subject to commercial or open-source
licensing.
By using JUCE, you agree to the terms of both the JUCE 7 End-User License
Agreement and JUCE Privacy Policy.
End User License Agreement: www.juce.com/juce-7-licence
Privacy Policy: www.juce.com/juce-privacy-policy
Or: You may also use this code under the terms of the GPL v3 (see
www.gnu.org/licenses).
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
DISCLAIMED.
==============================================================================
*/
namespace juce
{
//==============================================================================
/**
The base class for objects which can draw themselves, e.g. polygons, images, etc.
@see DrawableComposite, DrawableImage, DrawablePath, DrawableText
@tags{GUI}
*/
class JUCE_API Drawable : public Component
{
protected:
//==============================================================================
/** The base class can't be instantiated directly.
@see DrawableComposite, DrawableImage, DrawablePath, DrawableText
*/
Drawable();
public:
/** Destructor. */
~Drawable() override;
//==============================================================================
/** Creates a deep copy of this Drawable object.
Use this to create a new copy of this and any sub-objects in the tree.
*/
virtual std::unique_ptr<Drawable> createCopy() const = 0;
/** Creates a path that describes the outline of this drawable. */
virtual Path getOutlineAsPath() const = 0;
//==============================================================================
/** Renders this Drawable object.
Note that the preferred way to render a drawable in future is by using it
as a component and adding it to a parent, so you might want to consider that
before using this method.
@see drawWithin
*/
void draw (Graphics& g, float opacity,
const AffineTransform& transform = AffineTransform()) const;
/** Renders the Drawable at a given offset within the Graphics context.
The coordinates passed-in are used to translate the object relative to its own
origin before drawing it - this is basically a quick way of saying:
@code
draw (g, AffineTransform::translation (x, y)).
@endcode
Note that the preferred way to render a drawable in future is by using it
as a component and adding it to a parent, so you might want to consider that
before using this method.
*/
void drawAt (Graphics& g, float x, float y, float opacity) const;
/** Renders the Drawable within a rectangle, scaling it to fit neatly inside without
changing its aspect-ratio.
The object can placed arbitrarily within the rectangle based on a Justification type,
and can either be made as big as possible, or just reduced to fit.
Note that the preferred way to render a drawable in future is by using it
as a component and adding it to a parent, so you might want to consider that
before using this method.
@param g the graphics context to render onto
@param destArea the target rectangle to fit the drawable into
@param placement defines the alignment and rescaling to use to fit
this object within the target rectangle.
@param opacity the opacity to use, in the range 0 to 1.0
*/
void drawWithin (Graphics& g,
Rectangle<float> destArea,
RectanglePlacement placement,
float opacity) const;
//==============================================================================
/** Resets any transformations on this drawable, and positions its origin within
its parent component.
*/
void setOriginWithOriginalSize (Point<float> originWithinParent);
/** Sets a transform for this drawable that will position it within the specified
area of its parent component.
*/
void setTransformToFit (const Rectangle<float>& areaInParent, RectanglePlacement placement);
/** Returns the DrawableComposite that contains this object, if there is one. */
DrawableComposite* getParent() const;
/** Sets a the clipping region of this drawable using another drawable.
The drawable passed in will be deleted when no longer needed.
*/
void setClipPath (std::unique_ptr<Drawable> drawableClipPath);
//==============================================================================
/** Tries to turn some kind of image file into a drawable.
The data could be an image that the ImageFileFormat class understands, or it
could be SVG.
*/
static std::unique_ptr<Drawable> createFromImageData (const void* data, size_t numBytes);
/** Tries to turn a stream containing some kind of image data into a drawable.
The data could be an image that the ImageFileFormat class understands, or it
could be SVG.
*/
static std::unique_ptr<Drawable> createFromImageDataStream (InputStream& dataSource);
/** Tries to turn a file containing some kind of image data into a drawable.
The data could be an image that the ImageFileFormat class understands, or it
could be SVG.
*/
static std::unique_ptr<Drawable> createFromImageFile (const File& file);
/** Attempts to parse an SVG (Scalable Vector Graphics) document, and to turn this
into a Drawable tree.
If something goes wrong while parsing, it may return nullptr.
SVG is a pretty large and complex spec, and this doesn't aim to be a full
implementation, but it can return the basic vector objects.
*/
static std::unique_ptr<Drawable> createFromSVG (const XmlElement& svgDocument);
/** Attempts to parse an SVG (Scalable Vector Graphics) document from a file,
and to turn this into a Drawable tree.
If something goes wrong while parsing, it may return nullptr.
SVG is a pretty large and complex spec, and this doesn't aim to be a full
implementation, but it can return the basic vector objects.
Any references to references to external image files will be relative to
the parent directory of the file passed.
*/
static std::unique_ptr<Drawable> createFromSVGFile (const File& svgFile);
/** Parses an SVG path string and returns it. */
static Path parseSVGPath (const String& svgPath);
//==============================================================================
/** Returns the area that this drawable covers.
The result is expressed in this drawable's own coordinate space, and does not take
into account any transforms that may be applied to the component.
*/
virtual Rectangle<float> getDrawableBounds() const = 0;
/** Recursively replaces a colour that might be used for filling or stroking.
return true if any instances of this colour were found.
*/
virtual bool replaceColour (Colour originalColour, Colour replacementColour);
/** Sets a transformation that applies to the same coordinate system in which the rest of the
draw calls are made. You almost certainly want to call this function when working with
Drawables as opposed to Component::setTransform().
The reason for this is that the origin of a Drawable is not the same as the point returned
by Component::getPosition() but has an additional offset internal to the Drawable class.
Using setDrawableTransform() will take this internal offset into account when applying the
transform to the Component base.
You can only use Drawable::setDrawableTransform() or Component::setTransform() for a given
object. Using both will lead to unpredictable behaviour.
*/
void setDrawableTransform (const AffineTransform& transform);
protected:
//==============================================================================
friend class DrawableComposite;
friend class DrawableShape;
/** @internal */
void transformContextToCorrectOrigin (Graphics&);
/** @internal */
void parentHierarchyChanged() override;
/** @internal */
void setBoundsToEnclose (Rectangle<float>);
/** @internal */
void applyDrawableClipPath (Graphics&);
Point<int> originRelativeToComponent;
std::unique_ptr<Drawable> drawableClipPath;
AffineTransform drawableTransform;
void nonConstDraw (Graphics&, float opacity, const AffineTransform&);
void updateTransform();
Drawable (const Drawable&);
Drawable& operator= (const Drawable&);
JUCE_LEAK_DETECTOR (Drawable)
};
} // namespace juce

328
deps/juce/modules/juce_gui_basics/drawables/juce_DrawableComposite.cpp vendored
View File

@ -1,164 +1,164 @@
/*
==============================================================================
This file is part of the JUCE library.
Copyright (c) 2020 - Raw Material Software Limited
JUCE is an open source library subject to commercial or open-source
licensing.
By using JUCE, you agree to the terms of both the JUCE 6 End-User License
Agreement and JUCE Privacy Policy (both effective as of the 16th June 2020).
End User License Agreement: www.juce.com/juce-6-licence
Privacy Policy: www.juce.com/juce-privacy-policy
Or: You may also use this code under the terms of the GPL v3 (see
www.gnu.org/licenses).
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
DISCLAIMED.
==============================================================================
*/
namespace juce
{
DrawableComposite::DrawableComposite()
: bounds ({ 0.0f, 0.0f, 100.0f, 100.0f })
{
setContentArea ({ 0.0f, 0.0f, 100.0f, 100.0f });
}
DrawableComposite::DrawableComposite (const DrawableComposite& other)
: Drawable (other),
bounds (other.bounds),
contentArea (other.contentArea)
{
for (auto* c : other.getChildren())
if (auto* d = dynamic_cast<const Drawable*> (c))
addAndMakeVisible (d->createCopy().release());
}
DrawableComposite::~DrawableComposite()
{
deleteAllChildren();
}
std::unique_ptr<Drawable> DrawableComposite::createCopy() const
{
return std::make_unique<DrawableComposite> (*this);
}
//==============================================================================
Rectangle<float> DrawableComposite::getDrawableBounds() const
{
Rectangle<float> r;
for (auto* c : getChildren())
if (auto* d = dynamic_cast<const Drawable*> (c))
r = r.getUnion (d->isTransformed() ? d->getDrawableBounds().transformedBy (d->getTransform())
: d->getDrawableBounds());
return r;
}
void DrawableComposite::setContentArea (Rectangle<float> newArea)
{
contentArea = newArea;
}
void DrawableComposite::setBoundingBox (Rectangle<float> newBounds)
{
setBoundingBox (Parallelogram<float> (newBounds));
}
void DrawableComposite::setBoundingBox (Parallelogram<float> newBounds)
{
if (bounds != newBounds)
{
bounds = newBounds;
auto t = AffineTransform::fromTargetPoints (contentArea.getTopLeft(), bounds.topLeft,
contentArea.getTopRight(), bounds.topRight,
contentArea.getBottomLeft(), bounds.bottomLeft);
if (t.isSingularity())
t = {};
setTransform (t);
}
}
void DrawableComposite::resetBoundingBoxToContentArea()
{
setBoundingBox (contentArea);
}
void DrawableComposite::resetContentAreaAndBoundingBoxToFitChildren()
{
setContentArea (getDrawableBounds());
resetBoundingBoxToContentArea();
}
void DrawableComposite::parentHierarchyChanged()
{
if (auto* parent = getParent())
originRelativeToComponent = parent->originRelativeToComponent - getPosition();
}
void DrawableComposite::childBoundsChanged (Component*)
{
updateBoundsToFitChildren();
}
void DrawableComposite::childrenChanged()
{
updateBoundsToFitChildren();
}
void DrawableComposite::updateBoundsToFitChildren()
{
if (! updateBoundsReentrant)
{
const ScopedValueSetter<bool> setter (updateBoundsReentrant, true, false);
Rectangle<int> childArea;
for (auto* c : getChildren())
childArea = childArea.getUnion (c->getBoundsInParent());
auto delta = childArea.getPosition();
childArea += getPosition();
if (childArea != getBounds())
{
if (! delta.isOrigin())
{
originRelativeToComponent -= delta;
for (auto* c : getChildren())
c->setBounds (c->getBounds() - delta);
}
setBounds (childArea);
}
}
}
//==============================================================================
Path DrawableComposite::getOutlineAsPath() const
{
Path p;
for (auto* c : getChildren())
if (auto* d = dynamic_cast<Drawable*> (c))
p.addPath (d->getOutlineAsPath());
p.applyTransform (getTransform());
return p;
}
} // namespace juce
/*
==============================================================================
This file is part of the JUCE library.
Copyright (c) 2022 - Raw Material Software Limited
JUCE is an open source library subject to commercial or open-source
licensing.
By using JUCE, you agree to the terms of both the JUCE 7 End-User License
Agreement and JUCE Privacy Policy.
End User License Agreement: www.juce.com/juce-7-licence
Privacy Policy: www.juce.com/juce-privacy-policy
Or: You may also use this code under the terms of the GPL v3 (see
www.gnu.org/licenses).
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
DISCLAIMED.
==============================================================================
*/
namespace juce
{
DrawableComposite::DrawableComposite()
: bounds ({ 0.0f, 0.0f, 100.0f, 100.0f })
{
setContentArea ({ 0.0f, 0.0f, 100.0f, 100.0f });
}
DrawableComposite::DrawableComposite (const DrawableComposite& other)
: Drawable (other),
bounds (other.bounds),
contentArea (other.contentArea)
{
for (auto* c : other.getChildren())
if (auto* d = dynamic_cast<const Drawable*> (c))
addAndMakeVisible (d->createCopy().release());
}
DrawableComposite::~DrawableComposite()
{
deleteAllChildren();
}
std::unique_ptr<Drawable> DrawableComposite::createCopy() const
{
return std::make_unique<DrawableComposite> (*this);
}
//==============================================================================
Rectangle<float> DrawableComposite::getDrawableBounds() const
{
Rectangle<float> r;
for (auto* c : getChildren())
if (auto* d = dynamic_cast<const Drawable*> (c))
r = r.getUnion (d->isTransformed() ? d->getDrawableBounds().transformedBy (d->getTransform())
: d->getDrawableBounds());
return r;
}
void DrawableComposite::setContentArea (Rectangle<float> newArea)
{
contentArea = newArea;
}
void DrawableComposite::setBoundingBox (Rectangle<float> newBounds)
{
setBoundingBox (Parallelogram<float> (newBounds));
}
void DrawableComposite::setBoundingBox (Parallelogram<float> newBounds)
{
if (bounds != newBounds)
{
bounds = newBounds;
auto t = AffineTransform::fromTargetPoints (contentArea.getTopLeft(), bounds.topLeft,
contentArea.getTopRight(), bounds.topRight,
contentArea.getBottomLeft(), bounds.bottomLeft);
if (t.isSingularity())
t = {};
setTransform (t);
}
}
void DrawableComposite::resetBoundingBoxToContentArea()
{
setBoundingBox (contentArea);
}
void DrawableComposite::resetContentAreaAndBoundingBoxToFitChildren()
{
setContentArea (getDrawableBounds());
resetBoundingBoxToContentArea();
}
void DrawableComposite::parentHierarchyChanged()
{
if (auto* parent = getParent())
originRelativeToComponent = parent->originRelativeToComponent - getPosition();
}
void DrawableComposite::childBoundsChanged (Component*)
{
updateBoundsToFitChildren();
}
void DrawableComposite::childrenChanged()
{
updateBoundsToFitChildren();
}
void DrawableComposite::updateBoundsToFitChildren()
{
if (! updateBoundsReentrant)
{
const ScopedValueSetter<bool> setter (updateBoundsReentrant, true, false);
Rectangle<int> childArea;
for (auto* c : getChildren())
childArea = childArea.getUnion (c->getBoundsInParent());
auto delta = childArea.getPosition();
childArea += getPosition();
if (childArea != getBounds())
{
if (! delta.isOrigin())
{
originRelativeToComponent -= delta;
for (auto* c : getChildren())
c->setBounds (c->getBounds() - delta);
}
setBounds (childArea);
}
}
}
//==============================================================================
Path DrawableComposite::getOutlineAsPath() const
{
Path p;
for (auto* c : getChildren())
if (auto* d = dynamic_cast<Drawable*> (c))
p.addPath (d->getOutlineAsPath());
p.applyTransform (getTransform());
return p;
}
} // namespace juce

234
deps/juce/modules/juce_gui_basics/drawables/juce_DrawableComposite.h vendored
View File

@ -1,117 +1,117 @@
/*
==============================================================================
This file is part of the JUCE library.
Copyright (c) 2020 - Raw Material Software Limited
JUCE is an open source library subject to commercial or open-source
licensing.
By using JUCE, you agree to the terms of both the JUCE 6 End-User License
Agreement and JUCE Privacy Policy (both effective as of the 16th June 2020).
End User License Agreement: www.juce.com/juce-6-licence
Privacy Policy: www.juce.com/juce-privacy-policy
Or: You may also use this code under the terms of the GPL v3 (see
www.gnu.org/licenses).
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
DISCLAIMED.
==============================================================================
*/
namespace juce
{
//==============================================================================
/**
A drawable object which acts as a container for a set of other Drawables.
Note that although this is a Component, it takes ownership of its child components
and will delete them, so that you can use it as a self-contained graphic object.
The intention is that you should not add your own components to it, only add other
Drawable objects.
@see Drawable
@tags{GUI}
*/
class JUCE_API DrawableComposite : public Drawable
{
public:
//==============================================================================
/** Creates a composite Drawable. */
DrawableComposite();
/** Creates a copy of a DrawableComposite. */
DrawableComposite (const DrawableComposite&);
/** Destructor. */
~DrawableComposite() override;
//==============================================================================
/** Sets the parallelogram that defines the target position of the content rectangle when the drawable is rendered.
@see setContentArea
*/
void setBoundingBox (Parallelogram<float> newBoundingBox);
/** Sets the rectangle that defines the target position of the content rectangle when the drawable is rendered.
@see setContentArea
*/
void setBoundingBox (Rectangle<float> newBoundingBox);
/** Returns the parallelogram that defines the target position of the content rectangle when the drawable is rendered.
@see setBoundingBox
*/
Parallelogram<float> getBoundingBox() const noexcept { return bounds; }
/** Changes the bounding box transform to match the content area, so that any sub-items will
be drawn at their untransformed positions.
*/
void resetBoundingBoxToContentArea();
/** Returns the main content rectangle.
@see contentLeftMarkerName, contentRightMarkerName, contentTopMarkerName, contentBottomMarkerName
*/
Rectangle<float> getContentArea() const noexcept { return contentArea; }
/** Changes the main content area.
@see setBoundingBox, contentLeftMarkerName, contentRightMarkerName, contentTopMarkerName, contentBottomMarkerName
*/
void setContentArea (Rectangle<float> newArea);
/** Resets the content area and the bounding transform to fit around the area occupied
by the child components.
*/
void resetContentAreaAndBoundingBoxToFitChildren();
//==============================================================================
/** @internal */
std::unique_ptr<Drawable> createCopy() const override;
/** @internal */
Rectangle<float> getDrawableBounds() const override;
/** @internal */
void childBoundsChanged (Component*) override;
/** @internal */
void childrenChanged() override;
/** @internal */
void parentHierarchyChanged() override;
/** @internal */
Path getOutlineAsPath() const override;
private:
//==============================================================================
Parallelogram<float> bounds;
Rectangle<float> contentArea;
bool updateBoundsReentrant = false;
void updateBoundsToFitChildren();
DrawableComposite& operator= (const DrawableComposite&);
JUCE_LEAK_DETECTOR (DrawableComposite)
};
} // namespace juce
/*
==============================================================================
This file is part of the JUCE library.
Copyright (c) 2022 - Raw Material Software Limited
JUCE is an open source library subject to commercial or open-source
licensing.
By using JUCE, you agree to the terms of both the JUCE 7 End-User License
Agreement and JUCE Privacy Policy.
End User License Agreement: www.juce.com/juce-7-licence
Privacy Policy: www.juce.com/juce-privacy-policy
Or: You may also use this code under the terms of the GPL v3 (see
www.gnu.org/licenses).
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
DISCLAIMED.
==============================================================================
*/
namespace juce
{
//==============================================================================
/**
A drawable object which acts as a container for a set of other Drawables.
Note that although this is a Component, it takes ownership of its child components
and will delete them, so that you can use it as a self-contained graphic object.
The intention is that you should not add your own components to it, only add other
Drawable objects.
@see Drawable
@tags{GUI}
*/
class JUCE_API DrawableComposite : public Drawable
{
public:
//==============================================================================
/** Creates a composite Drawable. */
DrawableComposite();
/** Creates a copy of a DrawableComposite. */
DrawableComposite (const DrawableComposite&);
/** Destructor. */
~DrawableComposite() override;
//==============================================================================
/** Sets the parallelogram that defines the target position of the content rectangle when the drawable is rendered.
@see setContentArea
*/
void setBoundingBox (Parallelogram<float> newBoundingBox);
/** Sets the rectangle that defines the target position of the content rectangle when the drawable is rendered.
@see setContentArea
*/
void setBoundingBox (Rectangle<float> newBoundingBox);
/** Returns the parallelogram that defines the target position of the content rectangle when the drawable is rendered.
@see setBoundingBox
*/
Parallelogram<float> getBoundingBox() const noexcept { return bounds; }
/** Changes the bounding box transform to match the content area, so that any sub-items will
be drawn at their untransformed positions.
*/
void resetBoundingBoxToContentArea();
/** Returns the main content rectangle.
@see contentLeftMarkerName, contentRightMarkerName, contentTopMarkerName, contentBottomMarkerName
*/
Rectangle<float> getContentArea() const noexcept { return contentArea; }
/** Changes the main content area.
@see setBoundingBox, contentLeftMarkerName, contentRightMarkerName, contentTopMarkerName, contentBottomMarkerName
*/
void setContentArea (Rectangle<float> newArea);
/** Resets the content area and the bounding transform to fit around the area occupied
by the child components.
*/
void resetContentAreaAndBoundingBoxToFitChildren();
//==============================================================================
/** @internal */
std::unique_ptr<Drawable> createCopy() const override;
/** @internal */
Rectangle<float> getDrawableBounds() const override;
/** @internal */
void childBoundsChanged (Component*) override;
/** @internal */
void childrenChanged() override;
/** @internal */
void parentHierarchyChanged() override;
/** @internal */
Path getOutlineAsPath() const override;
private:
//==============================================================================
Parallelogram<float> bounds;
Rectangle<float> contentArea;
bool updateBoundsReentrant = false;
void updateBoundsToFitChildren();
DrawableComposite& operator= (const DrawableComposite&);
JUCE_LEAK_DETECTOR (DrawableComposite)
};
} // namespace juce

312
deps/juce/modules/juce_gui_basics/drawables/juce_DrawableImage.cpp vendored
View File

@ -1,156 +1,156 @@
/*
==============================================================================
This file is part of the JUCE library.
Copyright (c) 2020 - Raw Material Software Limited
JUCE is an open source library subject to commercial or open-source
licensing.
By using JUCE, you agree to the terms of both the JUCE 6 End-User License
Agreement and JUCE Privacy Policy (both effective as of the 16th June 2020).
End User License Agreement: www.juce.com/juce-6-licence
Privacy Policy: www.juce.com/juce-privacy-policy
Or: You may also use this code under the terms of the GPL v3 (see
www.gnu.org/licenses).
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
DISCLAIMED.
==============================================================================
*/
namespace juce
{
DrawableImage::DrawableImage() : bounds ({ 0.0f, 0.0f, 1.0f, 1.0f })
{
}
DrawableImage::DrawableImage (const DrawableImage& other)
: Drawable (other),
image (other.image),
opacity (other.opacity),
overlayColour (other.overlayColour),
bounds (other.bounds)
{
setBounds (other.getBounds());
}
DrawableImage::DrawableImage (const Image& imageToUse)
{
setImageInternal (imageToUse);
}
DrawableImage::~DrawableImage()
{
}
std::unique_ptr<Drawable> DrawableImage::createCopy() const
{
return std::make_unique<DrawableImage> (*this);
}
//==============================================================================
void DrawableImage::setImage (const Image& imageToUse)
{
if (setImageInternal (imageToUse))
repaint();
}
void DrawableImage::setOpacity (const float newOpacity)
{
opacity = newOpacity;
}
void DrawableImage::setOverlayColour (Colour newOverlayColour)
{
overlayColour = newOverlayColour;
}
void DrawableImage::setBoundingBox (Rectangle<float> newBounds)
{
setBoundingBox (Parallelogram<float> (newBounds));
}
void DrawableImage::setBoundingBox (Parallelogram<float> newBounds)
{
if (bounds != newBounds)
{
bounds = newBounds;
if (image.isValid())
{
auto tr = bounds.topLeft + (bounds.topRight - bounds.topLeft) / (float) image.getWidth();
auto bl = bounds.topLeft + (bounds.bottomLeft - bounds.topLeft) / (float) image.getHeight();
auto t = AffineTransform::fromTargetPoints (bounds.topLeft.x, bounds.topLeft.y,
tr.x, tr.y,
bl.x, bl.y);
if (t.isSingularity())
t = {};
setTransform (t);
}
}
}
//==============================================================================
void DrawableImage::paint (Graphics& g)
{
if (image.isValid())
{
if (opacity > 0.0f && ! overlayColour.isOpaque())
{
g.setOpacity (opacity);
g.drawImageAt (image, 0, 0, false);
}
if (! overlayColour.isTransparent())
{
g.setColour (overlayColour.withMultipliedAlpha (opacity));
g.drawImageAt (image, 0, 0, true);
}
}
}
Rectangle<float> DrawableImage::getDrawableBounds() const
{
return image.getBounds().toFloat();
}
bool DrawableImage::hitTest (int x, int y)
{
return Drawable::hitTest (x, y) && image.isValid() && image.getPixelAt (x, y).getAlpha() >= 127;
}
Path DrawableImage::getOutlineAsPath() const
{
return {}; // not applicable for images
}
//==============================================================================
bool DrawableImage::setImageInternal (const Image& imageToUse)
{
if (image != imageToUse)
{
image = imageToUse;
setBounds (image.getBounds());
setBoundingBox (image.getBounds().toFloat());
return true;
}
return false;
}
//==============================================================================
std::unique_ptr<AccessibilityHandler> DrawableImage::createAccessibilityHandler()
{
return std::make_unique<AccessibilityHandler> (*this, AccessibilityRole::image);
}
} // namespace juce
/*
==============================================================================
This file is part of the JUCE library.
Copyright (c) 2022 - Raw Material Software Limited
JUCE is an open source library subject to commercial or open-source
licensing.
By using JUCE, you agree to the terms of both the JUCE 7 End-User License
Agreement and JUCE Privacy Policy.
End User License Agreement: www.juce.com/juce-7-licence
Privacy Policy: www.juce.com/juce-privacy-policy
Or: You may also use this code under the terms of the GPL v3 (see
www.gnu.org/licenses).
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
DISCLAIMED.
==============================================================================
*/
namespace juce
{
DrawableImage::DrawableImage() : bounds ({ 0.0f, 0.0f, 1.0f, 1.0f })
{
}
DrawableImage::DrawableImage (const DrawableImage& other)
: Drawable (other),
image (other.image),
opacity (other.opacity),
overlayColour (other.overlayColour),
bounds (other.bounds)
{
setBounds (other.getBounds());
}
DrawableImage::DrawableImage (const Image& imageToUse)
{
setImageInternal (imageToUse);
}
DrawableImage::~DrawableImage()
{
}
std::unique_ptr<Drawable> DrawableImage::createCopy() const
{
return std::make_unique<DrawableImage> (*this);
}
//==============================================================================
void DrawableImage::setImage (const Image& imageToUse)
{
if (setImageInternal (imageToUse))
repaint();
}
void DrawableImage::setOpacity (const float newOpacity)
{
opacity = newOpacity;
}
void DrawableImage::setOverlayColour (Colour newOverlayColour)
{
overlayColour = newOverlayColour;
}
void DrawableImage::setBoundingBox (Rectangle<float> newBounds)
{
setBoundingBox (Parallelogram<float> (newBounds));
}
void DrawableImage::setBoundingBox (Parallelogram<float> newBounds)
{
if (bounds != newBounds)
{
bounds = newBounds;
if (image.isValid())
{
auto tr = bounds.topLeft + (bounds.topRight - bounds.topLeft) / (float) image.getWidth();
auto bl = bounds.topLeft + (bounds.bottomLeft - bounds.topLeft) / (float) image.getHeight();
auto t = AffineTransform::fromTargetPoints (bounds.topLeft.x, bounds.topLeft.y,
tr.x, tr.y,
bl.x, bl.y);
if (t.isSingularity())
t = {};
setTransform (t);
}
}
}
//==============================================================================
void DrawableImage::paint (Graphics& g)
{
if (image.isValid())
{
if (opacity > 0.0f && ! overlayColour.isOpaque())
{
g.setOpacity (opacity);
g.drawImageAt (image, 0, 0, false);
}
if (! overlayColour.isTransparent())
{
g.setColour (overlayColour.withMultipliedAlpha (opacity));
g.drawImageAt (image, 0, 0, true);
}
}
}
Rectangle<float> DrawableImage::getDrawableBounds() const
{
return image.getBounds().toFloat();
}
bool DrawableImage::hitTest (int x, int y)
{
return Drawable::hitTest (x, y) && image.isValid() && image.getPixelAt (x, y).getAlpha() >= 127;
}
Path DrawableImage::getOutlineAsPath() const
{
return {}; // not applicable for images
}
//==============================================================================
bool DrawableImage::setImageInternal (const Image& imageToUse)
{
if (image != imageToUse)
{
image = imageToUse;
setBounds (image.getBounds());
setBoundingBox (image.getBounds().toFloat());
return true;
}
return false;
}
//==============================================================================
std::unique_ptr<AccessibilityHandler> DrawableImage::createAccessibilityHandler()
{
return std::make_unique<AccessibilityHandler> (*this, AccessibilityRole::image);
}
} // namespace juce

232
deps/juce/modules/juce_gui_basics/drawables/juce_DrawableImage.h vendored
View File

@ -1,116 +1,116 @@
/*
==============================================================================
This file is part of the JUCE library.
Copyright (c) 2020 - Raw Material Software Limited
JUCE is an open source library subject to commercial or open-source
licensing.
By using JUCE, you agree to the terms of both the JUCE 6 End-User License
Agreement and JUCE Privacy Policy (both effective as of the 16th June 2020).
End User License Agreement: www.juce.com/juce-6-licence
Privacy Policy: www.juce.com/juce-privacy-policy
Or: You may also use this code under the terms of the GPL v3 (see
www.gnu.org/licenses).
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
DISCLAIMED.
==============================================================================
*/
namespace juce
{
//==============================================================================
/**
A drawable object which is a bitmap image.
@see Drawable
@tags{GUI}
*/
class JUCE_API DrawableImage : public Drawable
{
public:
//==============================================================================
DrawableImage();
DrawableImage (const DrawableImage&);
/** Sets the image that this drawable will render. */
explicit DrawableImage (const Image& imageToUse);
/** Destructor. */
~DrawableImage() override;
//==============================================================================
/** Sets the image that this drawable will render. */
void setImage (const Image& imageToUse);
/** Returns the current image. */
const Image& getImage() const noexcept { return image; }
/** Sets the opacity to use when drawing the image. */
void setOpacity (float newOpacity);
/** Returns the image's opacity. */
float getOpacity() const noexcept { return opacity; }
/** Sets a colour to draw over the image's alpha channel.
By default this is transparent so isn't drawn, but if you set a non-transparent
colour here, then it will be overlaid on the image, using the image's alpha
channel as a mask.
This is handy for doing things like darkening or lightening an image by overlaying
it with semi-transparent black or white.
*/
void setOverlayColour (Colour newOverlayColour);
/** Returns the overlay colour. */
Colour getOverlayColour() const noexcept { return overlayColour; }
/** Sets the bounding box within which the image should be displayed. */
void setBoundingBox (Parallelogram<float> newBounds);
/** Sets the bounding box within which the image should be displayed. */
void setBoundingBox (Rectangle<float> newBounds);
/** Returns the position to which the image's top-left corner should be remapped in the target
coordinate space when rendering this object.
@see setTransform
*/
Parallelogram<float> getBoundingBox() const noexcept { return bounds; }
//==============================================================================
/** @internal */
void paint (Graphics&) override;
/** @internal */
bool hitTest (int x, int y) override;
/** @internal */
std::unique_ptr<Drawable> createCopy() const override;
/** @internal */
Rectangle<float> getDrawableBounds() const override;
/** @internal */
Path getOutlineAsPath() const override;
private:
//==============================================================================
std::unique_ptr<AccessibilityHandler> createAccessibilityHandler() override;
bool setImageInternal (const Image&);
//==============================================================================
Image image;
float opacity = 1.0f;
Colour overlayColour { 0 };
Parallelogram<float> bounds;
DrawableImage& operator= (const DrawableImage&);
JUCE_LEAK_DETECTOR (DrawableImage)
};
} // namespace juce
/*
==============================================================================
This file is part of the JUCE library.
Copyright (c) 2022 - Raw Material Software Limited
JUCE is an open source library subject to commercial or open-source
licensing.
By using JUCE, you agree to the terms of both the JUCE 7 End-User License
Agreement and JUCE Privacy Policy.
End User License Agreement: www.juce.com/juce-7-licence
Privacy Policy: www.juce.com/juce-privacy-policy
Or: You may also use this code under the terms of the GPL v3 (see
www.gnu.org/licenses).
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
DISCLAIMED.
==============================================================================
*/
namespace juce
{
//==============================================================================
/**
A drawable object which is a bitmap image.
@see Drawable
@tags{GUI}
*/
class JUCE_API DrawableImage : public Drawable
{
public:
//==============================================================================
DrawableImage();
DrawableImage (const DrawableImage&);
/** Sets the image that this drawable will render. */
explicit DrawableImage (const Image& imageToUse);
/** Destructor. */
~DrawableImage() override;
//==============================================================================
/** Sets the image that this drawable will render. */
void setImage (const Image& imageToUse);
/** Returns the current image. */
const Image& getImage() const noexcept { return image; }
/** Sets the opacity to use when drawing the image. */
void setOpacity (float newOpacity);
/** Returns the image's opacity. */
float getOpacity() const noexcept { return opacity; }
/** Sets a colour to draw over the image's alpha channel.
By default this is transparent so isn't drawn, but if you set a non-transparent
colour here, then it will be overlaid on the image, using the image's alpha
channel as a mask.
This is handy for doing things like darkening or lightening an image by overlaying
it with semi-transparent black or white.
*/
void setOverlayColour (Colour newOverlayColour);
/** Returns the overlay colour. */
Colour getOverlayColour() const noexcept { return overlayColour; }
/** Sets the bounding box within which the image should be displayed. */
void setBoundingBox (Parallelogram<float> newBounds);
/** Sets the bounding box within which the image should be displayed. */
void setBoundingBox (Rectangle<float> newBounds);
/** Returns the position to which the image's top-left corner should be remapped in the target
coordinate space when rendering this object.
@see setTransform
*/
Parallelogram<float> getBoundingBox() const noexcept { return bounds; }
//==============================================================================
/** @internal */
void paint (Graphics&) override;
/** @internal */
bool hitTest (int x, int y) override;
/** @internal */
std::unique_ptr<Drawable> createCopy() const override;
/** @internal */
Rectangle<float> getDrawableBounds() const override;
/** @internal */
Path getOutlineAsPath() const override;
private:
//==============================================================================
std::unique_ptr<AccessibilityHandler> createAccessibilityHandler() override;
bool setImageInternal (const Image&);
//==============================================================================
Image image;
float opacity = 1.0f;
Colour overlayColour { 0 };
Parallelogram<float> bounds;
DrawableImage& operator= (const DrawableImage&);
JUCE_LEAK_DETECTOR (DrawableImage)
};
} // namespace juce

114
deps/juce/modules/juce_gui_basics/drawables/juce_DrawablePath.cpp vendored
View File

@ -1,57 +1,57 @@
/*
==============================================================================
This file is part of the JUCE library.
Copyright (c) 2020 - Raw Material Software Limited
JUCE is an open source library subject to commercial or open-source
licensing.
By using JUCE, you agree to the terms of both the JUCE 6 End-User License
Agreement and JUCE Privacy Policy (both effective as of the 16th June 2020).
End User License Agreement: www.juce.com/juce-6-licence
Privacy Policy: www.juce.com/juce-privacy-policy
Or: You may also use this code under the terms of the GPL v3 (see
www.gnu.org/licenses).
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
DISCLAIMED.
==============================================================================
*/
namespace juce
{
DrawablePath::DrawablePath() {}
DrawablePath::~DrawablePath() {}
DrawablePath::DrawablePath (const DrawablePath& other) : DrawableShape (other)
{
setPath (other.path);
}
std::unique_ptr<Drawable> DrawablePath::createCopy() const
{
return std::make_unique<DrawablePath> (*this);
}
void DrawablePath::setPath (const Path& newPath)
{
path = newPath;
pathChanged();
}
void DrawablePath::setPath (Path&& newPath)
{
path = std::move (newPath);
pathChanged();
}
const Path& DrawablePath::getPath() const { return path; }
const Path& DrawablePath::getStrokePath() const { return strokePath; }
} // namespace juce
/*
==============================================================================
This file is part of the JUCE library.
Copyright (c) 2022 - Raw Material Software Limited
JUCE is an open source library subject to commercial or open-source
licensing.
By using JUCE, you agree to the terms of both the JUCE 7 End-User License
Agreement and JUCE Privacy Policy.
End User License Agreement: www.juce.com/juce-7-licence
Privacy Policy: www.juce.com/juce-privacy-policy
Or: You may also use this code under the terms of the GPL v3 (see
www.gnu.org/licenses).
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
DISCLAIMED.
==============================================================================
*/
namespace juce
{
DrawablePath::DrawablePath() {}
DrawablePath::~DrawablePath() {}
DrawablePath::DrawablePath (const DrawablePath& other) : DrawableShape (other)
{
setPath (other.path);
}
std::unique_ptr<Drawable> DrawablePath::createCopy() const
{
return std::make_unique<DrawablePath> (*this);
}
void DrawablePath::setPath (const Path& newPath)
{
path = newPath;
pathChanged();
}
void DrawablePath::setPath (Path&& newPath)
{
path = std::move (newPath);
pathChanged();
}
const Path& DrawablePath::getPath() const { return path; }
const Path& DrawablePath::getStrokePath() const { return strokePath; }
} // namespace juce

154
deps/juce/modules/juce_gui_basics/drawables/juce_DrawablePath.h vendored
View File

@ -1,77 +1,77 @@
/*
==============================================================================
This file is part of the JUCE library.
Copyright (c) 2020 - Raw Material Software Limited
JUCE is an open source library subject to commercial or open-source
licensing.
By using JUCE, you agree to the terms of both the JUCE 6 End-User License
Agreement and JUCE Privacy Policy (both effective as of the 16th June 2020).
End User License Agreement: www.juce.com/juce-6-licence
Privacy Policy: www.juce.com/juce-privacy-policy
Or: You may also use this code under the terms of the GPL v3 (see
www.gnu.org/licenses).
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
DISCLAIMED.
==============================================================================
*/
namespace juce
{
//==============================================================================
/**
A drawable object which renders a filled or outlined shape.
For details on how to change the fill and stroke, see the DrawableShape class.
@see Drawable, DrawableShape
@tags{GUI}
*/
class JUCE_API DrawablePath : public DrawableShape
{
public:
//==============================================================================
/** Creates a DrawablePath. */
DrawablePath();
DrawablePath (const DrawablePath&);
/** Destructor. */
~DrawablePath() override;
//==============================================================================
/** Changes the path that will be drawn.
@see setFill, setStrokeType
*/
void setPath (const Path& newPath);
/** Changes the path that will be drawn.
@see setFill, setStrokeType
*/
void setPath (Path&& newPath);
/** Returns the current path. */
const Path& getPath() const;
/** Returns the current path for the outline. */
const Path& getStrokePath() const;
//==============================================================================
/** @internal */
std::unique_ptr<Drawable> createCopy() const override;
private:
//==============================================================================
DrawablePath& operator= (const DrawablePath&);
JUCE_LEAK_DETECTOR (DrawablePath)
};
} // namespace juce
/*
==============================================================================
This file is part of the JUCE library.
Copyright (c) 2022 - Raw Material Software Limited
JUCE is an open source library subject to commercial or open-source
licensing.
By using JUCE, you agree to the terms of both the JUCE 7 End-User License
Agreement and JUCE Privacy Policy.
End User License Agreement: www.juce.com/juce-7-licence
Privacy Policy: www.juce.com/juce-privacy-policy
Or: You may also use this code under the terms of the GPL v3 (see
www.gnu.org/licenses).
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
DISCLAIMED.
==============================================================================
*/
namespace juce
{
//==============================================================================
/**
A drawable object which renders a filled or outlined shape.
For details on how to change the fill and stroke, see the DrawableShape class.
@see Drawable, DrawableShape
@tags{GUI}
*/
class JUCE_API DrawablePath : public DrawableShape
{
public:
//==============================================================================
/** Creates a DrawablePath. */
DrawablePath();
DrawablePath (const DrawablePath&);
/** Destructor. */
~DrawablePath() override;
//==============================================================================
/** Changes the path that will be drawn.
@see setFill, setStrokeType
*/
void setPath (const Path& newPath);
/** Changes the path that will be drawn.
@see setFill, setStrokeType
*/
void setPath (Path&& newPath);
/** Returns the current path. */
const Path& getPath() const;
/** Returns the current path for the outline. */
const Path& getStrokePath() const;
//==============================================================================
/** @internal */
std::unique_ptr<Drawable> createCopy() const override;
private:
//==============================================================================
DrawablePath& operator= (const DrawablePath&);
JUCE_LEAK_DETECTOR (DrawablePath)
};
} // namespace juce

174
deps/juce/modules/juce_gui_basics/drawables/juce_DrawableRectangle.cpp vendored
View File

@ -1,87 +1,87 @@
/*
==============================================================================
This file is part of the JUCE library.
Copyright (c) 2020 - Raw Material Software Limited
JUCE is an open source library subject to commercial or open-source
licensing.
By using JUCE, you agree to the terms of both the JUCE 6 End-User License
Agreement and JUCE Privacy Policy (both effective as of the 16th June 2020).
End User License Agreement: www.juce.com/juce-6-licence
Privacy Policy: www.juce.com/juce-privacy-policy
Or: You may also use this code under the terms of the GPL v3 (see
www.gnu.org/licenses).
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
DISCLAIMED.
==============================================================================
*/
namespace juce
{
DrawableRectangle::DrawableRectangle() {}
DrawableRectangle::~DrawableRectangle() {}
DrawableRectangle::DrawableRectangle (const DrawableRectangle& other)
: DrawableShape (other),
bounds (other.bounds),
cornerSize (other.cornerSize)
{
rebuildPath();
}
std::unique_ptr<Drawable> DrawableRectangle::createCopy() const
{
return std::make_unique<DrawableRectangle> (*this);
}
//==============================================================================
void DrawableRectangle::setRectangle (Parallelogram<float> newBounds)
{
if (bounds != newBounds)
{
bounds = newBounds;
rebuildPath();
}
}
void DrawableRectangle::setCornerSize (Point<float> newSize)
{
if (cornerSize != newSize)
{
cornerSize = newSize;
rebuildPath();
}
}
void DrawableRectangle::rebuildPath()
{
auto w = bounds.getWidth();
auto h = bounds.getHeight();
Path newPath;
if (cornerSize.x > 0 && cornerSize.y > 0)
newPath.addRoundedRectangle (0, 0, w, h, cornerSize.x, cornerSize.y);
else
newPath.addRectangle (0, 0, w, h);
newPath.applyTransform (AffineTransform::fromTargetPoints (Point<float>(), bounds.topLeft,
Point<float> (w, 0), bounds.topRight,
Point<float> (0, h), bounds.bottomLeft));
if (path != newPath)
{
path.swapWithPath (newPath);
pathChanged();
}
}
} // namespace juce
/*
==============================================================================
This file is part of the JUCE library.
Copyright (c) 2022 - Raw Material Software Limited
JUCE is an open source library subject to commercial or open-source
licensing.
By using JUCE, you agree to the terms of both the JUCE 7 End-User License
Agreement and JUCE Privacy Policy.
End User License Agreement: www.juce.com/juce-7-licence
Privacy Policy: www.juce.com/juce-privacy-policy
Or: You may also use this code under the terms of the GPL v3 (see
www.gnu.org/licenses).
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
DISCLAIMED.
==============================================================================
*/
namespace juce
{
DrawableRectangle::DrawableRectangle() {}
DrawableRectangle::~DrawableRectangle() {}
DrawableRectangle::DrawableRectangle (const DrawableRectangle& other)
: DrawableShape (other),
bounds (other.bounds),
cornerSize (other.cornerSize)
{
rebuildPath();
}
std::unique_ptr<Drawable> DrawableRectangle::createCopy() const
{
return std::make_unique<DrawableRectangle> (*this);
}
//==============================================================================
void DrawableRectangle::setRectangle (Parallelogram<float> newBounds)
{
if (bounds != newBounds)
{
bounds = newBounds;
rebuildPath();
}
}
void DrawableRectangle::setCornerSize (Point<float> newSize)
{
if (cornerSize != newSize)
{
cornerSize = newSize;
rebuildPath();
}
}
void DrawableRectangle::rebuildPath()
{
auto w = bounds.getWidth();
auto h = bounds.getHeight();
Path newPath;
if (cornerSize.x > 0 && cornerSize.y > 0)
newPath.addRoundedRectangle (0, 0, w, h, cornerSize.x, cornerSize.y);
else
newPath.addRectangle (0, 0, w, h);
newPath.applyTransform (AffineTransform::fromTargetPoints (Point<float>(), bounds.topLeft,
Point<float> (w, 0), bounds.topRight,
Point<float> (0, h), bounds.bottomLeft));
if (path != newPath)
{
path.swapWithPath (newPath);
pathChanged();
}
}
} // namespace juce

152
deps/juce/modules/juce_gui_basics/drawables/juce_DrawableRectangle.h vendored
View File

@ -1,76 +1,76 @@
/*
==============================================================================
This file is part of the JUCE library.
Copyright (c) 2020 - Raw Material Software Limited
JUCE is an open source library subject to commercial or open-source
licensing.
By using JUCE, you agree to the terms of both the JUCE 6 End-User License
Agreement and JUCE Privacy Policy (both effective as of the 16th June 2020).
End User License Agreement: www.juce.com/juce-6-licence
Privacy Policy: www.juce.com/juce-privacy-policy
Or: You may also use this code under the terms of the GPL v3 (see
www.gnu.org/licenses).
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
DISCLAIMED.
==============================================================================
*/
namespace juce
{
//==============================================================================
/**
A Drawable object which draws a rectangle.
For details on how to change the fill and stroke, see the DrawableShape class.
@see Drawable, DrawableShape
@tags{GUI}
*/
class JUCE_API DrawableRectangle : public DrawableShape
{
public:
//==============================================================================
DrawableRectangle();
DrawableRectangle (const DrawableRectangle&);
/** Destructor. */
~DrawableRectangle() override;
//==============================================================================
/** Sets the rectangle's bounds. */
void setRectangle (Parallelogram<float> newBounds);
/** Returns the rectangle's bounds. */
Parallelogram<float> getRectangle() const noexcept { return bounds; }
/** Returns the corner size to be used. */
Point<float> getCornerSize() const noexcept { return cornerSize; }
/** Sets a new corner size for the rectangle */
void setCornerSize (Point<float> newSize);
//==============================================================================
/** @internal */
std::unique_ptr<Drawable> createCopy() const override;
private:
Parallelogram<float> bounds;
Point<float> cornerSize;
void rebuildPath();
DrawableRectangle& operator= (const DrawableRectangle&);
JUCE_LEAK_DETECTOR (DrawableRectangle)
};
} // namespace juce
/*
==============================================================================
This file is part of the JUCE library.
Copyright (c) 2022 - Raw Material Software Limited
JUCE is an open source library subject to commercial or open-source
licensing.
By using JUCE, you agree to the terms of both the JUCE 7 End-User License
Agreement and JUCE Privacy Policy.
End User License Agreement: www.juce.com/juce-7-licence
Privacy Policy: www.juce.com/juce-privacy-policy
Or: You may also use this code under the terms of the GPL v3 (see
www.gnu.org/licenses).
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
DISCLAIMED.
==============================================================================
*/
namespace juce
{
//==============================================================================
/**
A Drawable object which draws a rectangle.
For details on how to change the fill and stroke, see the DrawableShape class.
@see Drawable, DrawableShape
@tags{GUI}
*/
class JUCE_API DrawableRectangle : public DrawableShape
{
public:
//==============================================================================
DrawableRectangle();
DrawableRectangle (const DrawableRectangle&);
/** Destructor. */
~DrawableRectangle() override;
//==============================================================================
/** Sets the rectangle's bounds. */
void setRectangle (Parallelogram<float> newBounds);
/** Returns the rectangle's bounds. */
Parallelogram<float> getRectangle() const noexcept { return bounds; }
/** Returns the corner size to be used. */
Point<float> getCornerSize() const noexcept { return cornerSize; }
/** Sets a new corner size for the rectangle */
void setCornerSize (Point<float> newSize);
//==============================================================================
/** @internal */
std::unique_ptr<Drawable> createCopy() const override;
private:
Parallelogram<float> bounds;
Point<float> cornerSize;
void rebuildPath();
DrawableRectangle& operator= (const DrawableRectangle&);
JUCE_LEAK_DETECTOR (DrawableRectangle)
};
} // namespace juce

362
deps/juce/modules/juce_gui_basics/drawables/juce_DrawableShape.cpp vendored
View File

@ -1,181 +1,181 @@
/*
==============================================================================
This file is part of the JUCE library.
Copyright (c) 2020 - Raw Material Software Limited
JUCE is an open source library subject to commercial or open-source
licensing.
By using JUCE, you agree to the terms of both the JUCE 6 End-User License
Agreement and JUCE Privacy Policy (both effective as of the 16th June 2020).
End User License Agreement: www.juce.com/juce-6-licence
Privacy Policy: www.juce.com/juce-privacy-policy
Or: You may also use this code under the terms of the GPL v3 (see
www.gnu.org/licenses).
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
DISCLAIMED.
==============================================================================
*/
namespace juce
{
DrawableShape::DrawableShape()
: strokeType (0.0f),
mainFill (Colours::black),
strokeFill (Colours::black)
{
}
DrawableShape::DrawableShape (const DrawableShape& other)
: Drawable (other),
strokeType (other.strokeType),
dashLengths (other.dashLengths),
mainFill (other.mainFill),
strokeFill (other.strokeFill)
{
}
DrawableShape::~DrawableShape()
{
}
//==============================================================================
void DrawableShape::setFill (const FillType& newFill)
{
if (mainFill != newFill)
{
mainFill = newFill;
repaint();
}
}
void DrawableShape::setStrokeFill (const FillType& newFill)
{
if (strokeFill != newFill)
{
strokeFill = newFill;
repaint();
}
}
void DrawableShape::setStrokeType (const PathStrokeType& newStrokeType)
{
if (strokeType != newStrokeType)
{
strokeType = newStrokeType;
strokeChanged();
}
}
void DrawableShape::setDashLengths (const Array<float>& newDashLengths)
{
if (dashLengths != newDashLengths)
{
dashLengths = newDashLengths;
strokeChanged();
}
}
void DrawableShape::setStrokeThickness (const float newThickness)
{
setStrokeType (PathStrokeType (newThickness, strokeType.getJointStyle(), strokeType.getEndStyle()));
}
bool DrawableShape::isStrokeVisible() const noexcept
{
return strokeType.getStrokeThickness() > 0.0f && ! strokeFill.isInvisible();
}
//==============================================================================
void DrawableShape::paint (Graphics& g)
{
transformContextToCorrectOrigin (g);
applyDrawableClipPath (g);
g.setFillType (mainFill);
g.fillPath (path);
if (isStrokeVisible())
{
g.setFillType (strokeFill);
g.fillPath (strokePath);
}
}
void DrawableShape::pathChanged()
{
strokeChanged();
}
void DrawableShape::strokeChanged()
{
strokePath.clear();
const float extraAccuracy = 4.0f;
if (dashLengths.isEmpty())
strokeType.createStrokedPath (strokePath, path, AffineTransform(), extraAccuracy);
else
strokeType.createDashedStroke (strokePath, path, dashLengths.getRawDataPointer(),
dashLengths.size(), AffineTransform(), extraAccuracy);
setBoundsToEnclose (getDrawableBounds());
repaint();
}
Rectangle<float> DrawableShape::getDrawableBounds() const
{
if (isStrokeVisible())
return strokePath.getBounds();
return path.getBounds();
}
bool DrawableShape::hitTest (int x, int y)
{
bool allowsClicksOnThisComponent, allowsClicksOnChildComponents;
getInterceptsMouseClicks (allowsClicksOnThisComponent, allowsClicksOnChildComponents);
if (! allowsClicksOnThisComponent)
return false;
auto globalX = (float) (x - originRelativeToComponent.x);
auto globalY = (float) (y - originRelativeToComponent.y);
return path.contains (globalX, globalY)
|| (isStrokeVisible() && strokePath.contains (globalX, globalY));
}
//==============================================================================
static bool replaceColourInFill (FillType& fill, Colour original, Colour replacement)
{
if (fill.colour == original && fill.isColour())
{
fill = FillType (replacement);
return true;
}
return false;
}
bool DrawableShape::replaceColour (Colour original, Colour replacement)
{
bool changed1 = replaceColourInFill (mainFill, original, replacement);
bool changed2 = replaceColourInFill (strokeFill, original, replacement);
return changed1 || changed2;
}
Path DrawableShape::getOutlineAsPath() const
{
auto outline = isStrokeVisible() ? strokePath : path;
outline.applyTransform (getTransform());
return outline;
}
} // namespace juce
/*
==============================================================================
This file is part of the JUCE library.
Copyright (c) 2022 - Raw Material Software Limited
JUCE is an open source library subject to commercial or open-source
licensing.
By using JUCE, you agree to the terms of both the JUCE 7 End-User License
Agreement and JUCE Privacy Policy.
End User License Agreement: www.juce.com/juce-7-licence
Privacy Policy: www.juce.com/juce-privacy-policy
Or: You may also use this code under the terms of the GPL v3 (see
www.gnu.org/licenses).
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
DISCLAIMED.
==============================================================================
*/
namespace juce
{
DrawableShape::DrawableShape()
: strokeType (0.0f),
mainFill (Colours::black),
strokeFill (Colours::black)
{
}
DrawableShape::DrawableShape (const DrawableShape& other)
: Drawable (other),
strokeType (other.strokeType),
dashLengths (other.dashLengths),
mainFill (other.mainFill),
strokeFill (other.strokeFill)
{
}
DrawableShape::~DrawableShape()
{
}
//==============================================================================
void DrawableShape::setFill (const FillType& newFill)
{
if (mainFill != newFill)
{
mainFill = newFill;
repaint();
}
}
void DrawableShape::setStrokeFill (const FillType& newFill)
{
if (strokeFill != newFill)
{
strokeFill = newFill;
repaint();
}
}
void DrawableShape::setStrokeType (const PathStrokeType& newStrokeType)
{
if (strokeType != newStrokeType)
{
strokeType = newStrokeType;
strokeChanged();
}
}
void DrawableShape::setDashLengths (const Array<float>& newDashLengths)
{
if (dashLengths != newDashLengths)
{
dashLengths = newDashLengths;
strokeChanged();
}
}
void DrawableShape::setStrokeThickness (const float newThickness)
{
setStrokeType (PathStrokeType (newThickness, strokeType.getJointStyle(), strokeType.getEndStyle()));
}
bool DrawableShape::isStrokeVisible() const noexcept
{
return strokeType.getStrokeThickness() > 0.0f && ! strokeFill.isInvisible();
}
//==============================================================================
void DrawableShape::paint (Graphics& g)
{
transformContextToCorrectOrigin (g);
applyDrawableClipPath (g);
g.setFillType (mainFill);
g.fillPath (path);
if (isStrokeVisible())
{
g.setFillType (strokeFill);
g.fillPath (strokePath);
}
}
void DrawableShape::pathChanged()
{
strokeChanged();
}
void DrawableShape::strokeChanged()
{
strokePath.clear();
const float extraAccuracy = 4.0f;
if (dashLengths.isEmpty())
strokeType.createStrokedPath (strokePath, path, AffineTransform(), extraAccuracy);
else
strokeType.createDashedStroke (strokePath, path, dashLengths.getRawDataPointer(),
dashLengths.size(), AffineTransform(), extraAccuracy);
setBoundsToEnclose (getDrawableBounds());
repaint();
}
Rectangle<float> DrawableShape::getDrawableBounds() const
{
if (isStrokeVisible())
return strokePath.getBounds();
return path.getBounds();
}
bool DrawableShape::hitTest (int x, int y)
{
bool allowsClicksOnThisComponent, allowsClicksOnChildComponents;
getInterceptsMouseClicks (allowsClicksOnThisComponent, allowsClicksOnChildComponents);
if (! allowsClicksOnThisComponent)
return false;
auto globalX = (float) (x - originRelativeToComponent.x);
auto globalY = (float) (y - originRelativeToComponent.y);
return path.contains (globalX, globalY)
|| (isStrokeVisible() && strokePath.contains (globalX, globalY));
}
//==============================================================================
static bool replaceColourInFill (FillType& fill, Colour original, Colour replacement)
{
if (fill.colour == original && fill.isColour())
{
fill = FillType (replacement);
return true;
}
return false;
}
bool DrawableShape::replaceColour (Colour original, Colour replacement)
{
bool changed1 = replaceColourInFill (mainFill, original, replacement);
bool changed2 = replaceColourInFill (strokeFill, original, replacement);
return changed1 || changed2;
}
Path DrawableShape::getOutlineAsPath() const
{
auto outline = isStrokeVisible() ? strokePath : path;
outline.applyTransform (getTransform());
return outline;
}
} // namespace juce

252
deps/juce/modules/juce_gui_basics/drawables/juce_DrawableShape.h vendored
View File

@ -1,126 +1,126 @@
/*
==============================================================================
This file is part of the JUCE library.
Copyright (c) 2020 - Raw Material Software Limited
JUCE is an open source library subject to commercial or open-source
licensing.
By using JUCE, you agree to the terms of both the JUCE 6 End-User License
Agreement and JUCE Privacy Policy (both effective as of the 16th June 2020).
End User License Agreement: www.juce.com/juce-6-licence
Privacy Policy: www.juce.com/juce-privacy-policy
Or: You may also use this code under the terms of the GPL v3 (see
www.gnu.org/licenses).
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
DISCLAIMED.
==============================================================================
*/
namespace juce
{
//==============================================================================
/**
A base class implementing common functionality for Drawable classes which
consist of some kind of filled and stroked outline.
@see DrawablePath, DrawableRectangle
@tags{GUI}
*/
class JUCE_API DrawableShape : public Drawable
{
protected:
//==============================================================================
DrawableShape();
DrawableShape (const DrawableShape&);
public:
/** Destructor. */
~DrawableShape() override;
//==============================================================================
/** Sets a fill type for the path.
This colour is used to fill the path - if you don't want the path to be
filled (e.g. if you're just drawing an outline), set this to a transparent
colour.
@see setPath, setStrokeFill
*/
void setFill (const FillType& newFill);
/** Returns the current fill type.
@see setFill
*/
const FillType& getFill() const noexcept { return mainFill; }
/** Sets the fill type with which the outline will be drawn.
@see setFill
*/
void setStrokeFill (const FillType& newStrokeFill);
/** Returns the current stroke fill.
@see setStrokeFill
*/
const FillType& getStrokeFill() const noexcept { return strokeFill; }
/** Changes the properties of the outline that will be drawn around the path.
If the stroke has 0 thickness, no stroke will be drawn.
@see setStrokeThickness, setStrokeColour
*/
void setStrokeType (const PathStrokeType& newStrokeType);
/** Changes the stroke thickness.
This is a shortcut for calling setStrokeType.
*/
void setStrokeThickness (float newThickness);
/** Returns the current outline style. */
const PathStrokeType& getStrokeType() const noexcept { return strokeType; }
/** Provides a set of dash lengths to use for stroking the path. */
void setDashLengths (const Array<float>& newDashLengths);
/** Returns the set of dash lengths that the path is using. */
const Array<float>& getDashLengths() const noexcept { return dashLengths; }
//==============================================================================
/** @internal */
Rectangle<float> getDrawableBounds() const override;
/** @internal */
void paint (Graphics&) override;
/** @internal */
bool hitTest (int x, int y) override;
/** @internal */
bool replaceColour (Colour originalColour, Colour replacementColour) override;
/** @internal */
Path getOutlineAsPath() const override;
protected:
//==============================================================================
/** Called when the cached path should be updated. */
void pathChanged();
/** Called when the cached stroke should be updated. */
void strokeChanged();
/** True if there's a stroke with a non-zero thickness and non-transparent colour. */
bool isStrokeVisible() const noexcept;
//==============================================================================
PathStrokeType strokeType;
Array<float> dashLengths;
Path path, strokePath;
private:
FillType mainFill, strokeFill;
DrawableShape& operator= (const DrawableShape&);
};
} // namespace juce
/*
==============================================================================
This file is part of the JUCE library.
Copyright (c) 2022 - Raw Material Software Limited
JUCE is an open source library subject to commercial or open-source
licensing.
By using JUCE, you agree to the terms of both the JUCE 7 End-User License
Agreement and JUCE Privacy Policy.
End User License Agreement: www.juce.com/juce-7-licence
Privacy Policy: www.juce.com/juce-privacy-policy
Or: You may also use this code under the terms of the GPL v3 (see
www.gnu.org/licenses).
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
DISCLAIMED.
==============================================================================
*/
namespace juce
{
//==============================================================================
/**
A base class implementing common functionality for Drawable classes which
consist of some kind of filled and stroked outline.
@see DrawablePath, DrawableRectangle
@tags{GUI}
*/
class JUCE_API DrawableShape : public Drawable
{
protected:
//==============================================================================
DrawableShape();
DrawableShape (const DrawableShape&);
public:
/** Destructor. */
~DrawableShape() override;
//==============================================================================
/** Sets a fill type for the path.
This colour is used to fill the path - if you don't want the path to be
filled (e.g. if you're just drawing an outline), set this to a transparent
colour.
@see setPath, setStrokeFill
*/
void setFill (const FillType& newFill);
/** Returns the current fill type.
@see setFill
*/
const FillType& getFill() const noexcept { return mainFill; }
/** Sets the fill type with which the outline will be drawn.
@see setFill
*/
void setStrokeFill (const FillType& newStrokeFill);
/** Returns the current stroke fill.
@see setStrokeFill
*/
const FillType& getStrokeFill() const noexcept { return strokeFill; }
/** Changes the properties of the outline that will be drawn around the path.
If the stroke has 0 thickness, no stroke will be drawn.
@see setStrokeThickness, setStrokeColour
*/
void setStrokeType (const PathStrokeType& newStrokeType);
/** Changes the stroke thickness.
This is a shortcut for calling setStrokeType.
*/
void setStrokeThickness (float newThickness);
/** Returns the current outline style. */
const PathStrokeType& getStrokeType() const noexcept { return strokeType; }
/** Provides a set of dash lengths to use for stroking the path. */
void setDashLengths (const Array<float>& newDashLengths);
/** Returns the set of dash lengths that the path is using. */
const Array<float>& getDashLengths() const noexcept { return dashLengths; }
//==============================================================================
/** @internal */
Rectangle<float> getDrawableBounds() const override;
/** @internal */
void paint (Graphics&) override;
/** @internal */
bool hitTest (int x, int y) override;
/** @internal */
bool replaceColour (Colour originalColour, Colour replacementColour) override;
/** @internal */
Path getOutlineAsPath() const override;
protected:
//==============================================================================
/** Called when the cached path should be updated. */
void pathChanged();
/** Called when the cached stroke should be updated. */
void strokeChanged();
/** True if there's a stroke with a non-zero thickness and non-transparent colour. */
bool isStrokeVisible() const noexcept;
//==============================================================================
PathStrokeType strokeType;
Array<float> dashLengths;
Path path, strokePath;
private:
FillType mainFill, strokeFill;
DrawableShape& operator= (const DrawableShape&);
};
} // namespace juce

464
deps/juce/modules/juce_gui_basics/drawables/juce_DrawableText.cpp vendored
View File

@ -1,232 +1,232 @@
/*
==============================================================================
This file is part of the JUCE library.
Copyright (c) 2020 - Raw Material Software Limited
JUCE is an open source library subject to commercial or open-source
licensing.
By using JUCE, you agree to the terms of both the JUCE 6 End-User License
Agreement and JUCE Privacy Policy (both effective as of the 16th June 2020).
End User License Agreement: www.juce.com/juce-6-licence
Privacy Policy: www.juce.com/juce-privacy-policy
Or: You may also use this code under the terms of the GPL v3 (see
www.gnu.org/licenses).
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
DISCLAIMED.
==============================================================================
*/
namespace juce
{
DrawableText::DrawableText()
: colour (Colours::black),
justification (Justification::centredLeft)
{
setBoundingBox (Parallelogram<float> ({ 0.0f, 0.0f, 50.0f, 20.0f }));
setFont (Font (15.0f), true);
}
DrawableText::DrawableText (const DrawableText& other)
: Drawable (other),
bounds (other.bounds),
fontHeight (other.fontHeight),
fontHScale (other.fontHScale),
font (other.font),
text (other.text),
colour (other.colour),
justification (other.justification)
{
refreshBounds();
}
DrawableText::~DrawableText()
{
}
std::unique_ptr<Drawable> DrawableText::createCopy() const
{
return std::make_unique<DrawableText> (*this);
}
//==============================================================================
void DrawableText::setText (const String& newText)
{
if (text != newText)
{
text = newText;
refreshBounds();
}
}
void DrawableText::setColour (Colour newColour)
{
if (colour != newColour)
{
colour = newColour;
repaint();
}
}
void DrawableText::setFont (const Font& newFont, bool applySizeAndScale)
{
if (font != newFont)
{
font = newFont;
if (applySizeAndScale)
{
fontHeight = font.getHeight();
fontHScale = font.getHorizontalScale();
}
refreshBounds();
}
}
void DrawableText::setJustification (Justification newJustification)
{
justification = newJustification;
repaint();
}
void DrawableText::setBoundingBox (Parallelogram<float> newBounds)
{
if (bounds != newBounds)
{
bounds = newBounds;
refreshBounds();
}
}
void DrawableText::setFontHeight (float newHeight)
{
if (fontHeight != newHeight)
{
fontHeight = newHeight;
refreshBounds();
}
}
void DrawableText::setFontHorizontalScale (float newScale)
{
if (fontHScale != newScale)
{
fontHScale = newScale;
refreshBounds();
}
}
void DrawableText::refreshBounds()
{
auto w = bounds.getWidth();
auto h = bounds.getHeight();
auto height = jlimit (0.01f, jmax (0.01f, h), fontHeight);
auto hscale = jlimit (0.01f, jmax (0.01f, w), fontHScale);
scaledFont = font;
scaledFont.setHeight (height);
scaledFont.setHorizontalScale (hscale);
setBoundsToEnclose (getDrawableBounds());
repaint();
}
//==============================================================================
Rectangle<int> DrawableText::getTextArea (float w, float h) const
{
return Rectangle<float> (w, h).getSmallestIntegerContainer();
}
AffineTransform DrawableText::getTextTransform (float w, float h) const
{
return AffineTransform::fromTargetPoints (Point<float>(), bounds.topLeft,
Point<float> (w, 0), bounds.topRight,
Point<float> (0, h), bounds.bottomLeft);
}
void DrawableText::paint (Graphics& g)
{
transformContextToCorrectOrigin (g);
auto w = bounds.getWidth();
auto h = bounds.getHeight();
g.addTransform (getTextTransform (w, h));
g.setFont (scaledFont);
g.setColour (colour);
g.drawFittedText (text, getTextArea (w, h), justification, 0x100000);
}
Rectangle<float> DrawableText::getDrawableBounds() const
{
return bounds.getBoundingBox();
}
Path DrawableText::getOutlineAsPath() const
{
auto w = bounds.getWidth();
auto h = bounds.getHeight();
auto area = getTextArea (w, h).toFloat();
GlyphArrangement arr;
arr.addFittedText (scaledFont, text,
area.getX(), area.getY(),
area.getWidth(), area.getHeight(),
justification,
0x100000);
Path pathOfAllGlyphs;
for (auto& glyph : arr)
{
Path gylphPath;
glyph.createPath (gylphPath);
pathOfAllGlyphs.addPath (gylphPath);
}
pathOfAllGlyphs.applyTransform (getTextTransform (w, h).followedBy (getTransform()));
return pathOfAllGlyphs;
}
bool DrawableText::replaceColour (Colour originalColour, Colour replacementColour)
{
if (colour != originalColour)
return false;
setColour (replacementColour);
return true;
}
//==============================================================================
std::unique_ptr<AccessibilityHandler> DrawableText::createAccessibilityHandler()
{
class DrawableTextAccessibilityHandler : public AccessibilityHandler
{
public:
DrawableTextAccessibilityHandler (DrawableText& drawableTextToWrap)
: AccessibilityHandler (drawableTextToWrap, AccessibilityRole::staticText),
drawableText (drawableTextToWrap)
{
}
String getTitle() const override { return drawableText.getText(); }
private:
DrawableText& drawableText;
};
return std::make_unique<DrawableTextAccessibilityHandler> (*this);
}
} // namespace juce
/*
==============================================================================
This file is part of the JUCE library.
Copyright (c) 2022 - Raw Material Software Limited
JUCE is an open source library subject to commercial or open-source
licensing.
By using JUCE, you agree to the terms of both the JUCE 7 End-User License
Agreement and JUCE Privacy Policy.
End User License Agreement: www.juce.com/juce-7-licence
Privacy Policy: www.juce.com/juce-privacy-policy
Or: You may also use this code under the terms of the GPL v3 (see
www.gnu.org/licenses).
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
DISCLAIMED.
==============================================================================
*/
namespace juce
{
DrawableText::DrawableText()
: colour (Colours::black),
justification (Justification::centredLeft)
{
setBoundingBox (Parallelogram<float> ({ 0.0f, 0.0f, 50.0f, 20.0f }));
setFont (Font (15.0f), true);
}
DrawableText::DrawableText (const DrawableText& other)
: Drawable (other),
bounds (other.bounds),
fontHeight (other.fontHeight),
fontHScale (other.fontHScale),
font (other.font),
text (other.text),
colour (other.colour),
justification (other.justification)
{
refreshBounds();
}
DrawableText::~DrawableText()
{
}
std::unique_ptr<Drawable> DrawableText::createCopy() const
{
return std::make_unique<DrawableText> (*this);
}
//==============================================================================
void DrawableText::setText (const String& newText)
{
if (text != newText)
{
text = newText;
refreshBounds();
}
}
void DrawableText::setColour (Colour newColour)
{
if (colour != newColour)
{
colour = newColour;
repaint();
}
}
void DrawableText::setFont (const Font& newFont, bool applySizeAndScale)
{
if (font != newFont)
{
font = newFont;
if (applySizeAndScale)
{
fontHeight = font.getHeight();
fontHScale = font.getHorizontalScale();
}
refreshBounds();
}
}
void DrawableText::setJustification (Justification newJustification)
{
justification = newJustification;
repaint();
}
void DrawableText::setBoundingBox (Parallelogram<float> newBounds)
{
if (bounds != newBounds)
{
bounds = newBounds;
refreshBounds();
}
}
void DrawableText::setFontHeight (float newHeight)
{
if (fontHeight != newHeight)
{
fontHeight = newHeight;
refreshBounds();
}
}
void DrawableText::setFontHorizontalScale (float newScale)
{
if (fontHScale != newScale)
{
fontHScale = newScale;
refreshBounds();
}
}
void DrawableText::refreshBounds()
{
auto w = bounds.getWidth();
auto h = bounds.getHeight();
auto height = jlimit (0.01f, jmax (0.01f, h), fontHeight);
auto hscale = jlimit (0.01f, jmax (0.01f, w), fontHScale);
scaledFont = font;
scaledFont.setHeight (height);
scaledFont.setHorizontalScale (hscale);
setBoundsToEnclose (getDrawableBounds());
repaint();
}
//==============================================================================
Rectangle<int> DrawableText::getTextArea (float w, float h) const
{
return Rectangle<float> (w, h).getSmallestIntegerContainer();
}
AffineTransform DrawableText::getTextTransform (float w, float h) const
{
return AffineTransform::fromTargetPoints (Point<float>(), bounds.topLeft,
Point<float> (w, 0), bounds.topRight,
Point<float> (0, h), bounds.bottomLeft);
}
void DrawableText::paint (Graphics& g)
{
transformContextToCorrectOrigin (g);
auto w = bounds.getWidth();
auto h = bounds.getHeight();
g.addTransform (getTextTransform (w, h));
g.setFont (scaledFont);
g.setColour (colour);
g.drawFittedText (text, getTextArea (w, h), justification, 0x100000);
}
Rectangle<float> DrawableText::getDrawableBounds() const
{
return bounds.getBoundingBox();
}
Path DrawableText::getOutlineAsPath() const
{
auto w = bounds.getWidth();
auto h = bounds.getHeight();
auto area = getTextArea (w, h).toFloat();
GlyphArrangement arr;
arr.addFittedText (scaledFont, text,
area.getX(), area.getY(),
area.getWidth(), area.getHeight(),
justification,
0x100000);
Path pathOfAllGlyphs;
for (auto& glyph : arr)
{
Path gylphPath;
glyph.createPath (gylphPath);
pathOfAllGlyphs.addPath (gylphPath);
}
pathOfAllGlyphs.applyTransform (getTextTransform (w, h).followedBy (getTransform()));
return pathOfAllGlyphs;
}
bool DrawableText::replaceColour (Colour originalColour, Colour replacementColour)
{
if (colour != originalColour)
return false;
setColour (replacementColour);
return true;
}
//==============================================================================
std::unique_ptr<AccessibilityHandler> DrawableText::createAccessibilityHandler()
{
class DrawableTextAccessibilityHandler : public AccessibilityHandler
{
public:
DrawableTextAccessibilityHandler (DrawableText& drawableTextToWrap)
: AccessibilityHandler (drawableTextToWrap, AccessibilityRole::staticText),
drawableText (drawableTextToWrap)
{
}
String getTitle() const override { return drawableText.getText(); }
private:
DrawableText& drawableText;
};
return std::make_unique<DrawableTextAccessibilityHandler> (*this);
}
} // namespace juce

240
deps/juce/modules/juce_gui_basics/drawables/juce_DrawableText.h vendored
View File

@ -1,120 +1,120 @@
/*
==============================================================================
This file is part of the JUCE library.
Copyright (c) 2020 - Raw Material Software Limited
JUCE is an open source library subject to commercial or open-source
licensing.
By using JUCE, you agree to the terms of both the JUCE 6 End-User License
Agreement and JUCE Privacy Policy (both effective as of the 16th June 2020).
End User License Agreement: www.juce.com/juce-6-licence
Privacy Policy: www.juce.com/juce-privacy-policy
Or: You may also use this code under the terms of the GPL v3 (see
www.gnu.org/licenses).
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
DISCLAIMED.
==============================================================================
*/
namespace juce
{
//==============================================================================
/**
A drawable object which renders a line of text.
@see Drawable
@tags{GUI}
*/
class JUCE_API DrawableText : public Drawable
{
public:
//==============================================================================
/** Creates a DrawableText object. */
DrawableText();
DrawableText (const DrawableText&);
/** Destructor. */
~DrawableText() override;
//==============================================================================
/** Sets the text to display.*/
void setText (const String& newText);
/** Returns the currently displayed text */
const String& getText() const noexcept { return text;}
/** Sets the colour of the text. */
void setColour (Colour newColour);
/** Returns the current text colour. */
Colour getColour() const noexcept { return colour; }
/** Sets the font to use.
Note that the font height and horizontal scale are set using setFontHeight() and
setFontHorizontalScale(). If applySizeAndScale is true, then these height
and scale values will be changed to match the dimensions of the font supplied;
if it is false, then the new font object's height and scale are ignored.
*/
void setFont (const Font& newFont, bool applySizeAndScale);
/** Returns the current font. */
const Font& getFont() const noexcept { return font; }
/** Changes the justification of the text within the bounding box. */
void setJustification (Justification newJustification);
/** Returns the current justification. */
Justification getJustification() const noexcept { return justification; }
/** Returns the parallelogram that defines the text bounding box. */
Parallelogram<float> getBoundingBox() const noexcept { return bounds; }
/** Sets the bounding box that contains the text. */
void setBoundingBox (Parallelogram<float> newBounds);
float getFontHeight() const noexcept { return fontHeight; }
void setFontHeight (float newHeight);
float getFontHorizontalScale() const noexcept { return fontHScale; }
void setFontHorizontalScale (float newScale);
//==============================================================================
/** @internal */
void paint (Graphics&) override;
/** @internal */
std::unique_ptr<Drawable> createCopy() const override;
/** @internal */
Rectangle<float> getDrawableBounds() const override;
/** @internal */
Path getOutlineAsPath() const override;
/** @internal */
bool replaceColour (Colour originalColour, Colour replacementColour) override;
private:
//==============================================================================
Parallelogram<float> bounds;
float fontHeight, fontHScale;
Font font, scaledFont;
String text;
Colour colour;
Justification justification;
std::unique_ptr<AccessibilityHandler> createAccessibilityHandler() override;
void refreshBounds();
Rectangle<int> getTextArea (float width, float height) const;
AffineTransform getTextTransform (float width, float height) const;
DrawableText& operator= (const DrawableText&);
JUCE_LEAK_DETECTOR (DrawableText)
};
} // namespace juce
/*
==============================================================================
This file is part of the JUCE library.
Copyright (c) 2022 - Raw Material Software Limited
JUCE is an open source library subject to commercial or open-source
licensing.
By using JUCE, you agree to the terms of both the JUCE 7 End-User License
Agreement and JUCE Privacy Policy.
End User License Agreement: www.juce.com/juce-7-licence
Privacy Policy: www.juce.com/juce-privacy-policy
Or: You may also use this code under the terms of the GPL v3 (see
www.gnu.org/licenses).
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
DISCLAIMED.
==============================================================================
*/
namespace juce
{
//==============================================================================
/**
A drawable object which renders a line of text.
@see Drawable
@tags{GUI}
*/
class JUCE_API DrawableText : public Drawable
{
public:
//==============================================================================
/** Creates a DrawableText object. */
DrawableText();
DrawableText (const DrawableText&);
/** Destructor. */
~DrawableText() override;
//==============================================================================
/** Sets the text to display.*/
void setText (const String& newText);
/** Returns the currently displayed text */
const String& getText() const noexcept { return text;}
/** Sets the colour of the text. */
void setColour (Colour newColour);
/** Returns the current text colour. */
Colour getColour() const noexcept { return colour; }
/** Sets the font to use.
Note that the font height and horizontal scale are set using setFontHeight() and
setFontHorizontalScale(). If applySizeAndScale is true, then these height
and scale values will be changed to match the dimensions of the font supplied;
if it is false, then the new font object's height and scale are ignored.
*/
void setFont (const Font& newFont, bool applySizeAndScale);
/** Returns the current font. */
const Font& getFont() const noexcept { return font; }
/** Changes the justification of the text within the bounding box. */
void setJustification (Justification newJustification);
/** Returns the current justification. */
Justification getJustification() const noexcept { return justification; }
/** Returns the parallelogram that defines the text bounding box. */
Parallelogram<float> getBoundingBox() const noexcept { return bounds; }
/** Sets the bounding box that contains the text. */
void setBoundingBox (Parallelogram<float> newBounds);
float getFontHeight() const noexcept { return fontHeight; }
void setFontHeight (float newHeight);
float getFontHorizontalScale() const noexcept { return fontHScale; }
void setFontHorizontalScale (float newScale);
//==============================================================================
/** @internal */
void paint (Graphics&) override;
/** @internal */
std::unique_ptr<Drawable> createCopy() const override;
/** @internal */
Rectangle<float> getDrawableBounds() const override;
/** @internal */
Path getOutlineAsPath() const override;
/** @internal */
bool replaceColour (Colour originalColour, Colour replacementColour) override;
private:
//==============================================================================
Parallelogram<float> bounds;
float fontHeight, fontHScale;
Font font, scaledFont;
String text;
Colour colour;
Justification justification;
std::unique_ptr<AccessibilityHandler> createAccessibilityHandler() override;
void refreshBounds();
Rectangle<int> getTextArea (float width, float height) const;
AffineTransform getTextTransform (float width, float height) const;
DrawableText& operator= (const DrawableText&);
JUCE_LEAK_DETECTOR (DrawableText)
};
} // namespace juce

3563
deps/juce/modules/juce_gui_basics/drawables/juce_SVGParser.cpp vendored
View File

File diff suppressed because it is too large Load Diff