DISTRHO
/
Ildaeil
mirror of https://github.com/DISTRHO/Ildaeil.git
1
0
Fork 0
Code Issues 0 Releases 4 Wiki Activity
Browse Source

Use dpf methods to find config dir, cleanup 

Signed-off-by: falkTX <falktx@falktx.com>
main
falkTX 5 months ago
parent
f0f783d87b
commit
5c0c0df3ef
Signed by: falkTX <falktx@falktx.com> GPG Key ID: CDBAA37ABC74FBA0
4 changed files with 122 additions and 217 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +7
    -16
      plugins/Common/IldaeilBasePlugin.hpp
  2. +6
    -41
      plugins/Common/IldaeilPlugin.cpp
  3. +60
    -98
      plugins/Common/IldaeilUI.cpp
  4. +49
    -62
      plugins/Common/PluginHostWindow.cpp

+ 7
- 16
plugins/Common/IldaeilBasePlugin.hpp View File

@@ -1,6 +1,6 @@
/*
* DISTRHO Ildaeil Plugin
* Copyright (C) 2021-2023 Filipe Coelho <falktx@falktx.com>
* Copyright (C) 2021-2025 Filipe Coelho <falktx@falktx.com>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
@@ -35,30 +35,21 @@ public:
static Mutex sPluginInfoLoadMutex;
static const char* getPluginPath(PluginType ptype);

const NativePluginDescriptor* fCarlaPluginDescriptor;
NativePluginHandle fCarlaPluginHandle;
const NativePluginDescriptor* fCarlaPluginDescriptor = nullptr;
NativePluginHandle fCarlaPluginHandle = nullptr;

NativeHostDescriptor fCarlaHostDescriptor;
CarlaHostHandle fCarlaHostHandle;
NativeHostDescriptor fCarlaHostDescriptor{};
CarlaHostHandle fCarlaHostHandle = nullptr;

String fBinaryPath;

void* fUI;
void* fUI = nullptr;

IldaeilBasePlugin()
: Plugin(0, 0, 1),
fCarlaPluginDescriptor(nullptr),
fCarlaPluginHandle(nullptr),
fCarlaHostHandle(nullptr),
fUI(nullptr)
{
memset(&fCarlaHostDescriptor, 0, sizeof(fCarlaHostDescriptor));
}
IldaeilBasePlugin() : Plugin(0, 0, 1) {}
};

// --------------------------------------------------------------------------------------------------------------------

const char* ildaeilConfigDir();
void ildaeilProjectLoadedFromDSP(void* ui);
void ildaeilParameterChangeForUI(void* ui, uint32_t index, float value);
void ildaeilResizeUI(void* ui, uint32_t width, uint32_t height);


+ 6
- 41
plugins/Common/IldaeilPlugin.cpp View File

@@ -1,6 +1,6 @@
/*
* DISTRHO Ildaeil Plugin
* Copyright (C) 2021-2024 Filipe Coelho <falktx@falktx.com>
* Copyright (C) 2021-2025 Filipe Coelho <falktx@falktx.com>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
@@ -316,63 +316,28 @@ const char* IldaeilBasePlugin::getPluginPath(const PluginType ptype)
// --------------------------------------------------------------------------------------------------------------------
const char* ildaeilConfigDir()
{
static water::String configDir;
if (configDir.isEmpty())
{
#if defined(CARLA_OS_WASM)
configDir = "/userfiles";
#elif defined(CARLA_OS_MAC)
configDir = getHomePath() + "/Documents/Ildaeil";
#elif defined(CARLA_OS_WIN)
configDir = water::File::getSpecialLocation(water::File::winMyDocuments).getFullPathName() + "\\Ildaeil";
#else
if (const char* const xdgEnv = getenv("XDG_CONFIG_HOME"))
configDir = xdgEnv;
else
configDir = getHomePath() + "/.config";
configDir += "/Ildaeil";
#endif
}
return configDir.toRawUTF8();
}
// --------------------------------------------------------------------------------------------------------------------
class IldaeilPlugin : public IldaeilBasePlugin
{
#if DISTRHO_PLUGIN_NUM_INPUTS == 0 || DISTRHO_PLUGIN_NUM_OUTPUTS == 0
float* fDummyBuffer;
float* fDummyBuffer = nullptr;
float* fDummyBuffers[2];
#endif
#if DISTRHO_PLUGIN_WANT_MIDI_INPUT
static constexpr const uint kMaxMidiEventCount = 512;
NativeMidiEvent* fMidiEvents;
NativeMidiEvent* fMidiEvents = nullptr;
#endif
mutable NativeTimeInfo fCarlaTimeInfo;
mutable NativeTimeInfo fCarlaTimeInfo{};
mutable water::MemoryOutputStream fLastProjectState;
uint32_t fLastLatencyValue;
uint32_t fLastLatencyValue = 0;
public:
IldaeilPlugin()
: IldaeilBasePlugin(),
#if DISTRHO_PLUGIN_NUM_INPUTS == 0 || DISTRHO_PLUGIN_NUM_OUTPUTS == 0
fDummyBuffer(nullptr),
#endif
#if DISTRHO_PLUGIN_WANT_MIDI_INPUT
fMidiEvents(nullptr),
#endif
fLastLatencyValue(0)
: IldaeilBasePlugin()
{
fCarlaPluginDescriptor = carla_get_native_rack_plugin();
DISTRHO_SAFE_ASSERT_RETURN(fCarlaPluginDescriptor != nullptr,);
memset(&fCarlaTimeInfo, 0, sizeof(fCarlaTimeInfo));
fCarlaHostDescriptor.handle = this;
fCarlaHostDescriptor.resourceDir = carla_get_library_folder();
fCarlaHostDescriptor.uiName = "Ildaeil";


+ 60
- 98
plugins/Common/IldaeilUI.cpp View File

@@ -1,6 +1,6 @@
/*
* DISTRHO Ildaeil Plugin
* Copyright (C) 2021-2024 Filipe Coelho <falktx@falktx.com>
* Copyright (C) 2021-2025 Filipe Coelho <falktx@falktx.com>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
@@ -16,6 +16,7 @@
*/

#include "IldaeilBasePlugin.hpp"
#include "DistrhoPluginUtils.hpp"
#include "DistrhoUI.hpp"

#if ILDAEIL_STANDALONE
@@ -78,53 +79,37 @@ class IldaeilUI : public UI,
};

struct PluginGenericUI {
char* title;
uint parameterCount;
char* title = nullptr;
uint parameterCount = 0;
struct Parameter {
char* name;
char* printformat;
uint32_t rindex;
bool boolean, bvalue, log, readonly;
float min, max, power;
Parameter()
: name(nullptr),
printformat(nullptr),
rindex(0),
boolean(false),
bvalue(false),
log(false),
readonly(false),
min(0.0f),
max(1.0f) {}
char* name = nullptr;
char* printformat = nullptr;
uint32_t rindex = 0;
bool boolean = false;
bool bvalue = false;
bool log = false;
bool readonly = false;
float min = 0.f;
float max = 1.f;
~Parameter()
{
std::free(name);
std::free(printformat);
}
}* parameters;
float* values;
}* parameters = nullptr;
float* values = nullptr;

uint presetCount;
uint presetCount = 0;
struct Preset {
uint32_t index;
char* name;
uint32_t index = 0;
char* name = nullptr;
~Preset()
{
std::free(name);
}
}* presets;
int currentPreset;
const char** presetStrings;

PluginGenericUI()
: title(nullptr),
parameterCount(0),
parameters(nullptr),
values(nullptr),
presetCount(0),
presets(nullptr),
currentPreset(-1),
presetStrings(nullptr) {}
}* presets = nullptr;
int currentPreset = -1;
const char** presetStrings = nullptr;

~PluginGenericUI()
{
@@ -144,7 +129,7 @@ class IldaeilUI : public UI,
kDrawingPluginGenericUI,
kDrawingErrorInit,
kDrawingErrorDraw
} fDrawingState;
} fDrawingState = kDrawingLoading;

enum {
kIdleInit,
@@ -161,46 +146,42 @@ class IldaeilUI : public UI,
kIdleNothing
} fIdleState = kIdleInit;

IldaeilBasePlugin* const fPlugin;
void* const fNativeWindowHandle;
PluginHostWindow fPluginHostWindow;
BinaryType fBinaryType;
PluginType fPluginType;
PluginType fNextPluginType;
uint fPluginId;
int fPluginSelected;
bool fPluginHasCustomUI;
bool fPluginHasEmbedUI;
bool fPluginHasFileOpen;
bool fPluginHasOutputParameters;
bool fPluginIsBridge;
bool fPluginIsIdling;
bool fPluginRunning;
bool fPluginWillRunInBridgeMode;
IldaeilBasePlugin* const fPlugin = static_cast<IldaeilBasePlugin*>(getPluginInstancePointer());
void* const fNativeWindowHandle = reinterpret_cast<void*>(getWindow().getNativeWindowHandle());
PluginHostWindow fPluginHostWindow { fNativeWindowHandle, this };
BinaryType fBinaryType = BINARY_NATIVE;
PluginType fPluginType = PLUGIN_LV2;
PluginType fNextPluginType = fPluginType;
uint fPluginId = 0;
int fPluginSelected = -1;
bool fPluginHasCustomUI = false;
bool fPluginHasEmbedUI = false;
bool fPluginHasFileOpen = false;
bool fPluginHasOutputParameters = false;
bool fPluginIsBridge = false;
bool fPluginIsIdling = false;
bool fPluginRunning = false;
bool fPluginWillRunInBridgeMode = false;
Mutex fPluginsMutex;
PluginInfoCache fCurrentPluginInfo;
PluginInfoCache fCurrentPluginInfo{};
std::vector<PluginInfoCache> fPlugins;
ScopedPointer<PluginGenericUI> fPluginGenericUI;

bool fPluginSearchActive;
bool fPluginSearchFirstShow;
char fPluginSearchString[0xff];
bool fPluginSearchActive = false;
bool fPluginSearchFirstShow = false;
char fPluginSearchString[0xff] = {};

String fPopupError, fPluginFilename, fDiscoveryTool;
Size<uint> fCurrentConstraintSize, fLastSize, fNextSize;
bool fIgnoreNextHostWindowResize;
bool fShowingHostWindow;
bool fUpdateGeometryConstraints;
bool fIgnoreNextHostWindowResize = false;
bool fShowingHostWindow = false;
bool fUpdateGeometryConstraints = false;

struct RunnerData {
bool needsReinit;
CarlaPluginDiscoveryHandle handle;
bool needsReinit = true;
CarlaPluginDiscoveryHandle handle = nullptr;

RunnerData()
: needsReinit(true),
handle(nullptr) {}
void init()
{
needsReinit = true;
@@ -216,32 +197,7 @@ class IldaeilUI : public UI,
public:
IldaeilUI()
: UI(kInitialWidth, kInitialHeight),
Runner("IldaeilScanner"),
fDrawingState(kDrawingLoading),
fIdleState(kIdleInit),
fPlugin((IldaeilBasePlugin*)getPluginInstancePointer()),
fNativeWindowHandle(reinterpret_cast<void*>(getWindow().getNativeWindowHandle())),
fPluginHostWindow(fNativeWindowHandle, this),
fBinaryType(BINARY_NATIVE),
fPluginType(PLUGIN_LV2),
fNextPluginType(fPluginType),
fPluginId(0),
fPluginSelected(-1),
fPluginHasCustomUI(false),
fPluginHasEmbedUI(false),
fPluginHasFileOpen(false),
fPluginHasOutputParameters(false),
fPluginIsBridge(false),
fPluginIsIdling(false),
fPluginRunning(false),
fPluginWillRunInBridgeMode(false),
fCurrentPluginInfo(),
fPluginSearchActive(false),
fPluginSearchFirstShow(false),
fIgnoreNextHostWindowResize(false),
fShowingHostWindow(false),
fUpdateGeometryConstraints(false),
fRunnerData()
Runner("IldaeilScanner")
{
const double scaleFactor = getScaleFactor();

@@ -1062,7 +1018,7 @@ protected:
// save plugin info into cache
if (sha1sum != nullptr)
{
const water::String configDir(ildaeilConfigDir());
const water::String configDir(getSpecialDir(kSpecialDirConfigForPlugin));
const water::File cacheFile((configDir + CARLA_OS_SEP_STR "cache" CARLA_OS_SEP_STR + sha1sum).toRawUTF8());

if (cacheFile.create().ok())
@@ -1095,13 +1051,17 @@ protected:
else
{
d_stderr("Failed to write cache file for %s%s%s",
ildaeilConfigDir(), CARLA_OS_SEP_STR "cache" CARLA_OS_SEP_STR, sha1sum);
getSpecialDir(kSpecialDirConfigForPlugin),
CARLA_OS_SEP_STR "cache" CARLA_OS_SEP_STR,
sha1sum);
}
}
else
{
d_stderr("Failed to write cache file directories for %s%s%s",
ildaeilConfigDir(), CARLA_OS_SEP_STR "cache" CARLA_OS_SEP_STR, sha1sum);
getSpecialDir(kSpecialDirConfigForPlugin),
CARLA_OS_SEP_STR "cache" CARLA_OS_SEP_STR,
sha1sum);
}
}

@@ -1182,7 +1142,7 @@ protected:
if (sha1sum == nullptr)
return false;

const water::String configDir(ildaeilConfigDir());
const water::String configDir(getSpecialDir(kSpecialDirConfigForPlugin));
const water::File cacheFile((configDir + CARLA_OS_SEP_STR "cache" CARLA_OS_SEP_STR + sha1sum).toRawUTF8());

if (cacheFile.existsAsFile())
@@ -1237,7 +1197,9 @@ protected:
else
{
d_stderr("Failed to read cache file for %s%s%s",
ildaeilConfigDir(), CARLA_OS_SEP_STR "cache" CARLA_OS_SEP_STR, sha1sum);
getSpecialDir(kSpecialDirConfigForPlugin),
CARLA_OS_SEP_STR "cache" CARLA_OS_SEP_STR,
sha1sum);
}
}



+ 49
- 62
plugins/Common/PluginHostWindow.cpp View File

@@ -1,6 +1,6 @@
/*
* DISTRHO Ildaeil Plugin
* Copyright (C) 2021-2024 Filipe Coelho <falktx@falktx.com>
* Copyright (C) 2021-2025 Filipe Coelho <falktx@falktx.com>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
@@ -54,82 +54,69 @@ struct PluginHostWindow::PrivateData
void* const windowHandle;
Callbacks* const pluginWindowCallbacks;

#if defined(DISTRHO_OS_HAIKU)
#elif defined(DISTRHO_OS_MAC)
NSView* pluginView;
#elif defined(DISTRHO_OS_WASM)
#elif defined(DISTRHO_OS_WINDOWS)
::HWND pluginWindow;
#else
::Display* display;
::Window pluginWindow;
#endif
uint xOffset, yOffset;

bool brokenOffsetFactor;
bool lookingForChildren;
#if defined(DISTRHO_OS_HAIKU)
#elif defined(DISTRHO_OS_MAC)
NSView* pluginView = nullptr;
#elif defined(DISTRHO_OS_WASM)
#elif defined(DISTRHO_OS_WINDOWS)
::HWND pluginWindow = nullptr;
#else
::Display* display = XOpenDisplay(nullptr);
::Window pluginWindow = 0;
#endif

uint xOffset = 0;
uint yOffset = 0;
bool brokenOffsetFactor = false;
bool lookingForChildren = false;

PrivateData(void* const wh, Callbacks* const cbs)
: windowHandle(wh),
pluginWindowCallbacks(cbs),
#if defined(DISTRHO_OS_HAIKU)
#elif defined(DISTRHO_OS_MAC)
pluginView(nullptr),
#elif defined(DISTRHO_OS_WASM)
#elif defined(DISTRHO_OS_WINDOWS)
pluginWindow(nullptr),
#else
display(nullptr),
pluginWindow(0),
#endif
xOffset(0),
yOffset(0),
brokenOffsetFactor(false),
lookingForChildren(false)
pluginWindowCallbacks(cbs)
{
#if defined(DISTRHO_OS_HAIKU)
#elif defined(DISTRHO_OS_MAC)
#elif defined(DISTRHO_OS_WASM)
#elif defined(DISTRHO_OS_WINDOWS)
#else
display = XOpenDisplay(nullptr);
DISTRHO_SAFE_ASSERT_RETURN(display != nullptr,)
#endif
#if defined(DISTRHO_OS_HAIKU)
#elif defined(DISTRHO_OS_MAC)
#elif defined(DISTRHO_OS_WASM)
#elif defined(DISTRHO_OS_WINDOWS)
#else
DISTRHO_SAFE_ASSERT_RETURN(display != nullptr,);
#endif
}

~PrivateData()
{
#if defined(DISTRHO_OS_HAIKU)
#elif defined(DISTRHO_OS_MAC)
#elif defined(DISTRHO_OS_WASM)
#elif defined(DISTRHO_OS_WINDOWS)
#else
#if defined(DISTRHO_OS_HAIKU)
#elif defined(DISTRHO_OS_MAC)
#elif defined(DISTRHO_OS_WASM)
#elif defined(DISTRHO_OS_WINDOWS)
#else
if (display != nullptr)
XCloseDisplay(display);
#endif
#endif
}

void restart()
{
lookingForChildren = true;
#if defined(DISTRHO_OS_HAIKU)
#elif defined(DISTRHO_OS_MAC)

#if defined(DISTRHO_OS_HAIKU)
#elif defined(DISTRHO_OS_MAC)
pluginView = nullptr;
#elif defined(DISTRHO_OS_WASM)
#elif defined(DISTRHO_OS_WINDOWS)
#elif defined(DISTRHO_OS_WASM)
#elif defined(DISTRHO_OS_WINDOWS)
pluginWindow = nullptr;
#else
#else
pluginWindow = 0;

for (XEvent event; XPending(display) > 0;)
XNextEvent(display, &event);
#endif
#endif
}

bool hide()
{
#if defined(DISTRHO_OS_HAIKU)
#elif defined(DISTRHO_OS_MAC)
#if defined(DISTRHO_OS_HAIKU)
#elif defined(DISTRHO_OS_MAC)
if (pluginView != nullptr)
{
[pluginView setHidden:YES];
@@ -137,15 +124,15 @@ struct PluginHostWindow::PrivateData
[NSOpenGLContext clearCurrentContext];
return true;
}
#elif defined(DISTRHO_OS_WASM)
#elif defined(DISTRHO_OS_WINDOWS)
#elif defined(DISTRHO_OS_WASM)
#elif defined(DISTRHO_OS_WINDOWS)
if (pluginWindow != nullptr)
{
ShowWindow(pluginWindow, SW_HIDE);
pluginWindow = nullptr;
return true;
}
#else
#else
if (pluginWindow != 0)
{
XUnmapWindow(display, pluginWindow);
@@ -153,7 +140,7 @@ struct PluginHostWindow::PrivateData
pluginWindow = 0;
return true;
}
#endif
#endif
return false;
}

@@ -320,19 +307,19 @@ struct PluginHostWindow::PrivateData

void setSize(const uint width, const uint height)
{
#if defined(DISTRHO_OS_HAIKU)
#elif defined(DISTRHO_OS_MAC)
#if defined(DISTRHO_OS_HAIKU)
#elif defined(DISTRHO_OS_MAC)
if (pluginView != nullptr)
[pluginView setFrameSize:NSMakeSize(width, height)];
#elif defined(DISTRHO_OS_WASM)
#elif defined(DISTRHO_OS_WINDOWS)
#elif defined(DISTRHO_OS_WASM)
#elif defined(DISTRHO_OS_WINDOWS)
if (pluginWindow != nullptr)
SetWindowPos(pluginWindow, 0, 0, 0, width, height,
SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOOWNERZORDER | SWP_NOZORDER);
#else
#else
if (pluginWindow != 0)
XResizeWindow(display, pluginWindow, width, height);
#endif
#endif
}
};



Write Preview
Loading…
Cancel
Save