ZoomableComponent.cpp

Go to the documentation of this file.

namespace krotos
{
    Range<float> ZoomableComponent::getHorizontalRange() const
    {
        float halfZoom = m_hZoom * 0.5f;
        return {m_hCenter - halfZoom, m_hCenter + halfZoom};
    }
 
    Range<float> ZoomableComponent::getVerticalRange() const
    {
        return {m_vCenter - m_vCenter * m_vZoom, m_vCenter + (1.0f - m_vCenter) * m_vZoom};
    }
 
    void ZoomableComponent::drawNormalisedZoomedRect(Graphics& g, const Rectangle<float>& rect) const
    {
        g.fillRect(rect.transformedBy(m_transform));
    }
 
    void ZoomableComponent::drawNormalisedZoomedRectLine(Graphics& g, const Rectangle<float>& rect) const
    {
        g.drawRect(rect.transformedBy(m_transform));
    }
 
    void ZoomableComponent::drawZoomedRect(Graphics& g, const Rectangle<float>& rect) const
    {
        auto width = float(getWidth());
        auto height = float(getHeight());
 
        auto normalised = Rectangle<float>(rect.getX() / width, rect.getY() / height, rect.getWidth() / width,
                                           rect.getHeight() / height);
 
        drawNormalisedZoomedRect(g, normalised);
    }
 
    void ZoomableComponent::drawNormalisedZoomedLine(Graphics& g, Line<float> line, float thickness) const
    {
        line.applyTransform(m_transform);
        g.drawLine(line, thickness);
    }
 
    void ZoomableComponent::drawNormalisedZoomedText(Graphics& g, String text, Rectangle<float> boundary) const
    {
        g.drawFittedText(text, boundary.transformedBy(m_transform).toNearestInt(), Justification::centredLeft, 1);
    }
 
    void ZoomableComponent::drawZoomedLine(Graphics& g, const Line<float>& line, float thickness) const
    {
        auto width = float(getWidth());
        auto height = float(getHeight());
 
        auto normalised = Line<float>(line.getStartX() / width, line.getStartY() / height, line.getEndX() / width,
                                      line.getEndY() / height);
 
        drawNormalisedZoomedLine(g, normalised, thickness);
    }
 
    void ZoomableComponent::drawNormalisedZoomedPath(Graphics& g, const Path& path, float thickness)
    {
        g.strokePath(path, PathStrokeType(thickness), m_transform);
    }
 
    void ZoomableComponent::drawZoomedPath(Graphics& g, Path path, float thickness)
    {
        auto width = float(getWidth());
        auto height = float(getHeight());
 
        auto t = AffineTransform::scale(1.0f / width, 1.0f / height);
        path.applyTransform(t);
 
        drawNormalisedZoomedPath(g, path, thickness);
    }
 
    void ZoomableComponent::drawNormalisedZoomedImage(Graphics& g, Image& image, const Rectangle<float>& bounds,
                                                      bool fillAlphaChannelWithCurrentBrush)
    {
        g.drawImage(image, bounds.transformedBy(m_transform), RectanglePlacement::stretchToFit,
                    fillAlphaChannelWithCurrentBrush);
    }
 
    void ZoomableComponent::fillNormalisedZoomedEllipse(Graphics& g, const Rectangle<float>& bounds)
    {
        g.fillEllipse(bounds.transformedBy(m_transform));
    }
 
    void ZoomableComponent::drawNormalisedZoomedEllipse(Graphics& g, const Rectangle<float>& bounds)
    {
        g.drawEllipse(bounds.transformedBy(m_transform), 1.f);
    }
 
    void ZoomableComponent::drawZoomedEllipse(Graphics& g, const Rectangle<float>& bounds)
    {
        auto width = float(getWidth());
        auto height = float(getHeight());
 
        auto normalised = Rectangle<float>(bounds.getX() / width, bounds.getY() / height, bounds.getWidth() / width,
                                           bounds.getHeight() / height);
 
        drawNormalisedZoomedEllipse(g, normalised);
    }
 
    void ZoomableComponent::updateTransform()
    {
        auto xr = getHorizontalRange();
        auto yr = getVerticalRange();
        auto height = float(getHeight());
        auto width = float(getWidth());
 
        m_transform =
                AffineTransform::fromTargetPoints(xr.getStart(), yr.getStart(), 0.0f, 0.0f, xr.getEnd(), yr.getStart(),
                                                  width, 0.0f, xr.getStart(), yr.getEnd(), 0.0f, height);
 
        repaint();
    }
 
    // Range should contain start and end of the section we want to fill the view with, normalised 0->1
    void ZoomableComponent::setHorizontalZoomFromRange(const Range<float> xr)
    {
        m_hCenter = (xr.getStart() + xr.getEnd()) * 0.5f;
        m_hZoom = -2.f * xr.getStart() + 2.f * m_hCenter;
        updateTransform();
    }
 
    void ZoomableComponent::SetTransformToFit(int width, int height)
    {
        m_hCenter = 0.5f;
        m_hZoom = 1.0f;
        auto xr = getHorizontalRange();
        auto yr = getVerticalRange();
        m_transform =
                AffineTransform::fromTargetPoints(xr.getStart(), yr.getStart(), 0.0f, 0.0f, xr.getEnd(), yr.getStart(),
                                                  width, 0.0f, xr.getStart(), yr.getEnd(), 0.0f, height);
    }
 
} // namespace krotos