git subrepo clone --branch=sono6good https://github.com/essej/JUCE.git deps/juce

subrepo:
  subdir:   "deps/juce"
  merged:   "b13f9084e"
upstream:
  origin:   "https://github.com/essej/JUCE.git"
  branch:   "sono6good"
  commit:   "b13f9084e"
git-subrepo:
  version:  "0.4.3"
  origin:   "https://github.com/ingydotnet/git-subrepo.git"
  commit:   "2f68596"

deps/juce/examples/CMake/GuiApp/CMakeLists.txt

@@ -0,0 +1,102 @@
+# Example GUI App CMakeLists.txt
+
+# To get started on a new GUI app, copy this entire folder (containing this file and C++ sources) to
+# a convenient location, and then start making modifications. For other examples of CMakeLists for
+# GUI apps, check `extras/Projucer` and `examples/DemoRunner` in the JUCE repo.
+
+# The first line of any CMake project should be a call to `cmake_minimum_required`, which checks
+# that the installed CMake will be able to understand the following CMakeLists, and ensures that
+# CMake's behaviour is compatible with the named version. This is a standard CMake command, so more
+# information can be found in the CMake docs.
+
+cmake_minimum_required(VERSION 3.15)
+
+# The top-level CMakeLists.txt file for a project must contain a literal, direct call to the
+# `project()` command. `project()` sets up some helpful variables that describe source/binary
+# directories, and the current project version. This is a standard CMake command.
+
+project(GUI_APP_EXAMPLE VERSION 0.0.1)
+
+# If you've installed JUCE somehow (via a package manager, or directly using the CMake install
+# target), you'll need to tell this project that it depends on the installed copy of JUCE. If you've
+# included JUCE directly in your source tree (perhaps as a submodule), you'll need to tell CMake to
+# include that subdirectory as part of the build.
+
+# find_package(JUCE CONFIG REQUIRED)        # If you've installed JUCE to your system
+# or
+# add_subdirectory(JUCE)                    # If you've put JUCE in a subdirectory called JUCE
+
+# If your app depends the VST2 SDK, perhaps to host VST2 plugins, CMake needs to be told where
+# to find the SDK on your system. This setup should be done before calling `juce_add_gui_app`.
+
+# juce_set_vst2_sdk_path(...)
+
+# `juce_add_gui_app` adds an executable target with the name passed as the first argument
+# (GuiAppExample here). This target is a normal CMake target, but has a lot of extra properties set
+# up by default. This function accepts many optional arguments. Check the readme at
+# `docs/CMake API.md` in the JUCE repo for the full list.
+
+juce_add_gui_app(GuiAppExample
+    # VERSION ...                       # Set this if the app version is different to the project version
+    # ICON_BIG ...                      # ICON_* arguments specify a path to an image file to use as an icon
+    # ICON_SMALL ...
+    # DOCUMENT_EXTENSIONS ...           # Specify file extensions that should be associated with this app
+    # COMPANY_NAME ...                  # Specify the name of the app's author
+    PRODUCT_NAME "Gui App Example")     # The name of the final executable, which can differ from the target name
+
+# `juce_generate_juce_header` will create a JuceHeader.h for a given target, which will be generated
+# into your build tree. This should be included with `#include <JuceHeader.h>`. The include path for
+# this header will be automatically added to the target. The main function of the JuceHeader is to
+# include all your JUCE module headers; if you're happy to include module headers directly, you
+# probably don't need to call this.
+
+# juce_generate_juce_header(GuiAppExample)
+
+# `target_sources` adds source files to a target. We pass the target that needs the sources as the
+# first argument, then a visibility parameter for the sources which should normally be PRIVATE.
+# Finally, we supply a list of source files that will be built into the target. This is a standard
+# CMake command.
+
+target_sources(GuiAppExample
+    PRIVATE
+        Main.cpp
+        MainComponent.cpp)
+
+# `target_compile_definitions` adds some preprocessor definitions to our target. In a Projucer
+# project, these might be passed in the 'Preprocessor Definitions' field. JUCE modules also make use
+# of compile definitions to switch certain features on/off, so if there's a particular feature you
+# need that's not on by default, check the module header for the correct flag to set here. These
+# definitions will be visible both to your code, and also the JUCE module code, so for new
+# definitions, pick unique names that are unlikely to collide! This is a standard CMake command.
+
+target_compile_definitions(GuiAppExample
+    PRIVATE
+        # JUCE_WEB_BROWSER and JUCE_USE_CURL would be on by default, but you might not need them.
+        JUCE_WEB_BROWSER=0  # If you remove this, add `NEEDS_WEB_BROWSER TRUE` to the `juce_add_gui_app` call
+        JUCE_USE_CURL=0     # If you remove this, add `NEEDS_CURL TRUE` to the `juce_add_gui_app` call
+        JUCE_APPLICATION_NAME_STRING="$<TARGET_PROPERTY:GuiAppExample,JUCE_PRODUCT_NAME>"
+        JUCE_APPLICATION_VERSION_STRING="$<TARGET_PROPERTY:GuiAppExample,JUCE_VERSION>")
+
+# If your target needs extra binary assets, you can add them here. The first argument is the name of
+# a new static library target that will include all the binary resources. There is an optional
+# `NAMESPACE` argument that can specify the namespace of the generated binary data class. Finally,
+# the SOURCES argument should be followed by a list of source files that should be built into the
+# static library. These source files can be of any kind (wav data, images, fonts, icons etc.).
+# Conversion to binary-data will happen when your target is built.
+
+# juce_add_binary_data(GuiAppData SOURCES ...)
+
+# `target_link_libraries` links libraries and JUCE modules to other libraries or executables. Here,
+# we're linking our executable target to the `juce::juce_gui_extra` module. Inter-module
+# dependencies are resolved automatically, so `juce_core`, `juce_events` and so on will also be
+# linked automatically. If we'd generated a binary data target above, we would need to link to it
+# here too. This is a standard CMake command.
+
+target_link_libraries(GuiAppExample
+    PRIVATE
+        # GuiAppData            # If we'd created a binary data target, we'd link to it here
+        juce::juce_gui_extra
+    PUBLIC
+        juce::juce_recommended_config_flags
+        juce::juce_recommended_lto_flags
+        juce::juce_recommended_warning_flags)

deps/juce/examples/CMake/GuiApp/Main.cpp

@@ -0,0 +1,101 @@
+#include "MainComponent.h"
+
+//==============================================================================
+class GuiAppApplication  : public juce::JUCEApplication
+{
+public:
+    //==============================================================================
+    GuiAppApplication() {}
+
+    // We inject these as compile definitions from the CMakeLists.txt
+    // If you've enabled the juce header with `juce_generate_juce_header(<thisTarget>)`
+    // you could `#include <JuceHeader.h>` and use `ProjectInfo::projectName` etc. instead.
+    const juce::String getApplicationName() override       { return JUCE_APPLICATION_NAME_STRING; }
+    const juce::String getApplicationVersion() override    { return JUCE_APPLICATION_VERSION_STRING; }
+    bool moreThanOneInstanceAllowed() override             { return true; }
+
+    //==============================================================================
+    void initialise (const juce::String& commandLine) override
+    {
+        // This method is where you should put your application's initialisation code..
+        juce::ignoreUnused (commandLine);
+
+        mainWindow.reset (new MainWindow (getApplicationName()));
+    }
+
+    void shutdown() override
+    {
+        // Add your application's shutdown code here..
+
+        mainWindow = nullptr; // (deletes our window)
+    }
+
+    //==============================================================================
+    void systemRequestedQuit() override
+    {
+        // This is called when the app is being asked to quit: you can ignore this
+        // request and let the app carry on running, or call quit() to allow the app to close.
+        quit();
+    }
+
+    void anotherInstanceStarted (const juce::String& commandLine) override
+    {
+        // When another instance of the app is launched while this one is running,
+        // this method is invoked, and the commandLine parameter tells you what
+        // the other instance's command-line arguments were.
+        juce::ignoreUnused (commandLine);
+    }
+
+    //==============================================================================
+    /*
+        This class implements the desktop window that contains an instance of
+        our MainComponent class.
+    */
+    class MainWindow    : public juce::DocumentWindow
+    {
+    public:
+        explicit MainWindow (juce::String name)
+            : DocumentWindow (name,
+                              juce::Desktop::getInstance().getDefaultLookAndFeel()
+                                                          .findColour (ResizableWindow::backgroundColourId),
+                              DocumentWindow::allButtons)
+        {
+            setUsingNativeTitleBar (true);
+            setContentOwned (new MainComponent(), true);
+
+           #if JUCE_IOS || JUCE_ANDROID
+            setFullScreen (true);
+           #else
+            setResizable (true, true);
+            centreWithSize (getWidth(), getHeight());
+           #endif
+
+            setVisible (true);
+        }
+
+        void closeButtonPressed() override
+        {
+            // This is called when the user tries to close this window. Here, we'll just
+            // ask the app to quit when this happens, but you can change this to do
+            // whatever you need.
+            JUCEApplication::getInstance()->systemRequestedQuit();
+        }
+
+        /* Note: Be careful if you override any DocumentWindow methods - the base
+           class uses a lot of them, so by overriding you might break its functionality.
+           It's best to do all your work in your content component instead, but if
+           you really have to override any DocumentWindow methods, make sure your
+           subclass also calls the superclass's method.
+        */
+
+    private:
+        JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (MainWindow)
+    };
+
+private:
+    std::unique_ptr<MainWindow> mainWindow;
+};
+
+//==============================================================================
+// This macro generates the main() routine that launches the app.
+START_JUCE_APPLICATION (GuiAppApplication)

deps/juce/examples/CMake/GuiApp/MainComponent.cpp

@@ -0,0 +1,25 @@
+#include "MainComponent.h"
+
+//==============================================================================
+MainComponent::MainComponent()
+{
+    setSize (600, 400);
+}
+
+//==============================================================================
+void MainComponent::paint (juce::Graphics& g)
+{
+    // (Our component is opaque, so we must completely fill the background with a solid colour)
+    g.fillAll (getLookAndFeel().findColour (juce::ResizableWindow::backgroundColourId));
+
+    g.setFont (juce::Font (16.0f));
+    g.setColour (juce::Colours::white);
+    g.drawText ("Hello World!", getLocalBounds(), juce::Justification::centred, true);
+}
+
+void MainComponent::resized()
+{
+    // This is called when the MainComponent is resized.
+    // If you add any child components, this is where you should
+    // update their positions.
+}

deps/juce/examples/CMake/GuiApp/MainComponent.h

@@ -0,0 +1,29 @@
+#pragma once
+
+// CMake builds don't use an AppConfig.h, so it's safe to include juce module headers
+// directly. If you need to remain compatible with Projucer-generated builds, and
+// have called `juce_generate_juce_header(<thisTarget>)` in your CMakeLists.txt,
+// you could `#include <JuceHeader.h>` here instead, to make all your module headers visible.
+#include <juce_gui_extra/juce_gui_extra.h>
+
+//==============================================================================
+/*
+    This component lives inside our window, and this is where you should put all
+    your controls and content.
+*/
+class MainComponent   : public juce::Component
+{
+public:
+    //==============================================================================
+    MainComponent();
+
+    //==============================================================================
+    void paint (juce::Graphics&) override;
+    void resized() override;
+
+private:
+    //==============================================================================
+    // Your private member variables go here...
+
+    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (MainComponent)
+};