juce_ComponentPeer.h

Go to the documentation of this file.

 /*
  ==============================================================================
 
   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
{
 
//==============================================================================
class JUCE_API  ComponentPeer : private FocusChangeListener
{
public:
    //==============================================================================
    enum StyleFlags
    {
        windowAppearsOnTaskbar                          = (1 << 0),   
        windowIsTemporary                               = (1 << 1),   
        windowIgnoresMouseClicks                        = (1 << 2),   
        windowHasTitleBar                               = (1 << 3),   
        windowIsResizable                               = (1 << 4),   
        windowHasMinimiseButton                         = (1 << 5),   
        windowHasMaximiseButton                         = (1 << 6),   
        windowHasCloseButton                            = (1 << 7),   
        windowHasDropShadow                             = (1 << 8),   
        windowRepaintedExplictly                        = (1 << 9),   
        windowIgnoresKeyPresses                         = (1 << 10),  
        windowRequiresSynchronousCoreGraphicsRendering  = (1 << 11),  
        windowIsSemiTransparent                         = (1 << 30)   
    };
 
    class JUCE_API  OptionalBorderSize final
    {
    public:
        OptionalBorderSize()                               : valid (false)                               {}
 
        explicit OptionalBorderSize (BorderSize<int> size) : valid (true), borderSize (std::move (size)) {}
 
        explicit operator bool() const noexcept { return valid; }
 
        const auto& operator*() const noexcept
        {
            jassert (valid);
            return borderSize;
        }
 
        const auto* operator->() const noexcept
        {
            jassert (valid);
            return &borderSize;
        }
 
    private:
        bool valid;
        BorderSize<int> borderSize;
    };
 
    //==============================================================================
    ComponentPeer (Component& component, int styleFlags);
 
    ~ComponentPeer() override;
 
    //==============================================================================
    Component& getComponent() noexcept                      { return component; }
 
    int getStyleFlags() const noexcept                      { return styleFlags; }
 
    uint32 getUniqueID() const noexcept                     { return uniqueID; }
 
    //==============================================================================
    virtual void* getNativeHandle() const = 0;
 
    virtual void setVisible (bool shouldBeVisible) = 0;
 
    virtual void setTitle (const String& title) = 0;
 
    virtual bool setDocumentEditedStatus (bool edited);
 
    virtual void setRepresentedFile (const File&);
 
    //==============================================================================
    virtual void setBounds (const Rectangle<int>& newBounds, bool isNowFullScreen) = 0;
 
    void updateBounds();
 
    virtual Rectangle<int> getBounds() const = 0;
 
    virtual Point<float> localToGlobal (Point<float> relativePosition) = 0;
 
    virtual Point<float> globalToLocal (Point<float> screenPosition) = 0;
 
    Point<int> localToGlobal (Point<int> relativePosition);
 
    Point<int> globalToLocal (Point<int> screenPosition);
 
    virtual Rectangle<int> localToGlobal (const Rectangle<int>& relativePosition);
 
    virtual Rectangle<int> globalToLocal (const Rectangle<int>& screenPosition);
 
    Rectangle<float> localToGlobal (const Rectangle<float>& relativePosition);
 
    Rectangle<float> globalToLocal (const Rectangle<float>& screenPosition);
 
    Rectangle<int> getAreaCoveredBy (const Component& subComponent) const;
 
    virtual void setMinimised (bool shouldBeMinimised) = 0;
 
    virtual bool isMinimised() const = 0;
 
    virtual void setFullScreen (bool shouldBeFullScreen) = 0;
 
    virtual bool isFullScreen() const = 0;
 
    virtual bool isKioskMode() const;
 
    void setNonFullScreenBounds (const Rectangle<int>& newBounds) noexcept;
 
    const Rectangle<int>& getNonFullScreenBounds() const noexcept;
 
    virtual void setIcon (const Image& newIcon) = 0;
 
    void setConstrainer (ComponentBoundsConstrainer* newConstrainer) noexcept;
 
    virtual void startHostManagedResize ([[maybe_unused]] Point<int> mouseDownPosition,
                                         [[maybe_unused]] ResizableBorderComponent::Zone zone) {}
 
    ComponentBoundsConstrainer* getConstrainer() const noexcept             { return constrainer; }
 
    virtual bool contains (Point<int> localPos, bool trueIfInAChildWindow) const = 0;
 
    virtual OptionalBorderSize getFrameSizeIfPresent() const = 0;
 
   #if JUCE_LINUX || JUCE_BSD
    [[deprecated ("Use getFrameSizeIfPresent instead.")]]
   #endif
    virtual BorderSize<int> getFrameSize() const = 0;
 
    void handleMovedOrResized();
 
    virtual void handleScreenSizeChange();
 
    //==============================================================================
    void handlePaint (LowLevelGraphicsContext& contextToPaintTo);
 
    //==============================================================================
    virtual bool setAlwaysOnTop (bool alwaysOnTop) = 0;
 
    virtual void toFront (bool takeKeyboardFocus) = 0;
 
    virtual void toBehind (ComponentPeer* other) = 0;
 
    void handleBroughtToFront();
 
    //==============================================================================
    virtual bool isFocused() const = 0;
 
    virtual void grabFocus() = 0;
 
    void handleFocusGain();
    void handleFocusLoss();
 
    Component* getLastFocusedSubcomponent() const noexcept;
 
    bool handleKeyPress (int keyCode, juce_wchar textCharacter);
 
    bool handleKeyPress (const KeyPress& key);
 
    bool handleKeyUpOrDown (bool isKeyDown);
 
    void handleModifierKeysChange();
 
    virtual void closeInputMethodContext();
 
    void refreshTextInputTarget();
 
    //==============================================================================
    TextInputTarget* findCurrentTextInputTarget();
 
    //==============================================================================
    virtual void repaint (const Rectangle<int>& area) = 0;
 
    virtual void performAnyPendingRepaintsNow() = 0;
 
    virtual void setAlpha (float newAlpha) = 0;
 
    //==============================================================================
    void handleMouseEvent (MouseInputSource::InputSourceType type, Point<float> positionWithinPeer, ModifierKeys newMods, float pressure,
                           float orientation, int64 time, PenDetails pen = {}, int touchIndex = 0);
 
    void handleMouseWheel (MouseInputSource::InputSourceType type, Point<float> positionWithinPeer,
                           int64 time, const MouseWheelDetails&, int touchIndex = 0);
 
    void handleMagnifyGesture (MouseInputSource::InputSourceType type, Point<float> positionWithinPeer,
                               int64 time, float scaleFactor, int touchIndex = 0);
 
    void handleUserClosingWindow();
 
    struct DragInfo
    {
        StringArray files;
        String text;
        Point<int> position;
 
        bool isEmpty() const noexcept       { return files.size() == 0 && text.isEmpty(); }
        void clear() noexcept               { files.clear(); text.clear(); }
    };
 
    bool handleDragMove (const DragInfo&);
    bool handleDragExit (const DragInfo&);
    bool handleDragDrop (const DragInfo&);
 
    //==============================================================================
    static int getNumPeers() noexcept;
 
    static ComponentPeer* getPeer (int index) noexcept;
 
    static ComponentPeer* getPeerFor (const Component*) noexcept;
 
    static bool isValidPeer (const ComponentPeer* peer) noexcept;
 
    //==============================================================================
    virtual StringArray getAvailableRenderingEngines() = 0;
    virtual int getCurrentRenderingEngine() const;
    virtual void setCurrentRenderingEngine (int index);
 
    //==============================================================================
    static ModifierKeys getCurrentModifiersRealtime() noexcept;
 
    //==============================================================================
    struct JUCE_API  ScaleFactorListener
    {
        virtual ~ScaleFactorListener() = default;
 
        virtual void nativeScaleFactorChanged (double newScaleFactor) = 0;
    };
 
    void addScaleFactorListener (ScaleFactorListener* listenerToAdd)          { scaleFactorListeners.add (listenerToAdd); }
 
    void removeScaleFactorListener (ScaleFactorListener* listenerToRemove)    { scaleFactorListeners.remove (listenerToRemove);  }
 
    //==============================================================================
    struct JUCE_API  VBlankListener
    {
        virtual ~VBlankListener() = default;
 
        virtual void onVBlank() = 0;
    };
 
    void addVBlankListener (VBlankListener* listenerToAdd)       { vBlankListeners.add (listenerToAdd); }
 
    void removeVBlankListener (VBlankListener* listenerToRemove) { vBlankListeners.remove (listenerToRemove); }
 
    //==============================================================================
    virtual double getPlatformScaleFactor() const noexcept    { return 1.0; }
 
    virtual void setHasChangedSinceSaved (bool) {}
 
 
    enum class Style
    {
        automatic,
 
        light,
 
        dark
    };
 
    void setAppStyle (Style s)
    {
        if (std::exchange (style, s) != style)
            appStyleChanged();
    }
 
    Style getAppStyle() const { return style; }
 
protected:
    //==============================================================================
    static void forceDisplayUpdate();
 
    Component& component;
    const int styleFlags;
    Rectangle<int> lastNonFullscreenBounds;
    ComponentBoundsConstrainer* constrainer = nullptr;
    static std::function<ModifierKeys()> getNativeRealtimeModifiers;
    ListenerList<ScaleFactorListener> scaleFactorListeners;
    ListenerList<VBlankListener> vBlankListeners;
    Style style = Style::automatic;
 
private:
    //==============================================================================
    virtual void appStyleChanged() {}
 
    virtual void textInputRequired (Point<int>, TextInputTarget&) = 0;
 
    virtual void dismissPendingTextInput();
 
    void globalFocusChanged (Component*) override;
    Component* getTargetForKeyPress();
 
    WeakReference<Component> lastFocusedComponent, dragAndDropTargetComponent;
    Component* lastDragAndDropCompUnderMouse = nullptr;
    TextInputTarget* textInputTarget = nullptr;
    const uint32 uniqueID;
    bool isWindowMinimised = false;
 
    //==============================================================================
    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (ComponentPeer)
};
 
} // namespace juce