void run5Tests()
{
ushort k = 0;
MyData allMyData[MAX_RT_EVENTS];
// Make a safe copy of events while clearing them
postRtEvents.mutex.lock();
while (! postRtEvents.data.isEmpty())
{
static MyData fallback = { { '\0' }, 0 };
const MyData& my(postRtEvents.data.getFirst(fallback, true));
allMyData[k++] = my;
}
postRtEvents.mutex.unlock();
carla_stdout("Post-Rt Event Count: %i", k);
assert(k == 5);
// data should be empty now
assert(postRtEvents.data.count() == 0);
assert(postRtEvents.data.isEmpty());
assert(postRtEvents.dataPendingRT.count() == 0);
assert(postRtEvents.dataPendingRT.isEmpty());
// Handle events now
for (ushort i=0; i < k; ++i)
{
const MyData& my(allMyData[i]);
carla_stdout("Got data: %i %s", my.id, my.str);
}
}
static void test_CarlaEngineUtils() noexcept
{
CARLA_BACKEND_USE_NAMESPACE
carla_stdout(EngineType2Str(kEngineTypeNull));
carla_stdout(EnginePortType2Str(kEnginePortTypeNull));
carla_stdout(EngineEventType2Str(kEngineEventTypeNull));
carla_stdout(EngineControlEventType2Str(kEngineControlEventTypeNull));
}
static void test_CarlaVstUtils() noexcept
{
AEffect effect;
carla_zeroStruct(effect);
effect.dispatcher = test_vst_dispatcher;
vstPluginCanDo(&effect, "test");
carla_stdout(vstEffectOpcode2str(effOpen));
carla_stdout(vstMasterOpcode2str(audioMasterAutomate));
}
CARLA_EXPORT
int XNextEvent(Display* display, XEvent* event)
{
const int ret = real_XNextEvent(display, event);
if (ret != 0)
return ret;
if (gCurrentlyMappedWindow == 0)
return ret;
if (event->type != ClientMessage)
return ret;
if (event->xclient.window != gCurrentlyMappedWindow)
return ret;
char* const type = XGetAtomName(display, event->xclient.message_type);
CARLA_SAFE_ASSERT_RETURN(type != nullptr, 0);
if (std::strcmp(type, "WM_PROTOCOLS") != 0)
return ret;
if ((Atom)event->xclient.data.l[0] != XInternAtom(display, "WM_DELETE_WINDOW", False))
return ret;
gCurrentWindowVisible = false;
gCurrentWindowMapped = false;
if (gInterposedCallback != nullptr)
gInterposedCallback(1, nullptr);
event->type = 0;
carla_stdout("XNextEvent close event caught, hiding UI instead");
return real_XUnmapWindow(display, gCurrentlyMappedWindow);
}
CARLA_EXPORT
int clone(int (*)(void*), void*, int, void*, ...)
{
carla_stdout("------------------------------- clone called");
errno = ENOSYS;
return -1;
}
CARLA_EXPORT
pid_t fork()
{
carla_stdout("------------------------------- fork called");
errno = ENOSYS;
return -1;
}
void uiShow(const bool show) override
{
if (show)
{
if (isPipeRunning())
{
writeFocusMessage();
return;
}
carla_stdout("Trying to start UI using \"%s\"", fExtUiPath.buffer());
CarlaExternalUI::setData(fExtUiPath, getSampleRate(), getUiName());
if (! CarlaExternalUI::startPipeServer(true))
{
uiClosed();
hostUiUnavailable();
}
}
else
{
CarlaExternalUI::stopPipeServer(2000);
}
}
static void test_CarlaDssiUtils() noexcept
{
const char* const ui = find_dssi_ui("/usr/lib/dssi/trivial_sampler.so", "aa");
CARLA_SAFE_ASSERT(ui != nullptr);
if (ui != nullptr)
{
carla_stdout("%s", ui);
assert(std::strcmp(ui, "/usr/lib/dssi/trivial_sampler/trivial_sampler_qt") == 0);
delete[] ui;
}
}
ScopedPluginAction(CarlaEngineProtectedData* const data, const EnginePostAction action, const unsigned int pluginId, const unsigned int value, const bool lockWait)
: kData(data)
{
kData->nextAction.mutex.lock();
CARLA_ASSERT(kData->nextAction.opcode == kEnginePostActionNull);
kData->nextAction.opcode = action;
kData->nextAction.pluginId = pluginId;
kData->nextAction.value = value;
if (lockWait)
{
// block wait for unlock on proccessing side
carla_stdout("ScopedPluginAction(%i) - blocking START", pluginId);
kData->nextAction.mutex.lock();
carla_stdout("ScopedPluginAction(%i) - blocking DONE", pluginId);
}
else
{
kData->doNextPluginAction(false);
}
}
int main()
{
const char* const filename = carla_get_library_filename();
CARLA_SAFE_ASSERT_RETURN(filename != nullptr && filename[0] != '\0', 1);
const char* const folder = carla_get_library_folder();
CARLA_SAFE_ASSERT_RETURN(folder != nullptr && folder[0] != '\0', 1);
const NativePluginDescriptor* const rack = carla_get_native_rack_plugin();
CARLA_SAFE_ASSERT_RETURN(rack != nullptr, 1);
const NativePluginDescriptor* const patchbay = carla_get_native_patchbay_plugin();
CARLA_SAFE_ASSERT_RETURN(patchbay != nullptr, 1);
const NativeHostDescriptor host = {
nullptr,
"", // resourceDir
"Carla Plugin UI",
0,
get_buffer_size,
get_sample_rate,
is_offline,
nullptr, // get_time_info
nullptr, // write_midi_event
nullptr, // ui_parameter_changed
nullptr, // ui_midi_program_changed
nullptr, // ui_custom_data_changed
nullptr, // ui_closed
nullptr, // ui_open_file
nullptr, // ui_save_file
nullptr, // dispatcher
};
const NativePluginHandle handle = rack->instantiate(&host);
CARLA_SAFE_ASSERT_RETURN(handle != nullptr, 1);
CarlaEngine* const engine = carla_get_native_plugin_engine(rack, handle);
CARLA_SAFE_ASSERT_RETURN(engine != nullptr, 1);
carla_stdout("Got Engine %p, %s, %i, %f",
engine, engine->getName(), engine->getBufferSize(), engine->getSampleRate());
rack->cleanup(handle);
return 0;
}
void uiShow(const bool show) override
{
if (show)
{
if (isOk())
return;
CarlaString path(getResourceDir() + fExtUiPath);
carla_stdout("Trying to start UI using \"%s\"", path.buffer());
CarlaExternalUI::setData(path, getSampleRate(), getUiName());
CarlaExternalUI::start();
}
else
{
CarlaExternalUI::stop();
}
}
static void test_CarlaBridgeUtils() noexcept
{
carla_stdout(PluginBridgeOscInfoType2str(kPluginBridgeOscPong));
carla_stdout(PluginBridgeRtOpcode2str(kPluginBridgeRtNull));
carla_stdout(PluginBridgeNonRtOpcode2str(kPluginBridgeNonRtNull));
}
static void test_CarlaBackendUtils() noexcept
{
CARLA_BACKEND_USE_NAMESPACE
carla_stdout(PluginOption2Str(PLUGIN_OPTION_FIXED_BUFFERS));
carla_stdout(BinaryType2Str(BINARY_NONE));
carla_stdout(PluginType2Str(PLUGIN_NONE));
carla_stdout(PluginCategory2Str(PLUGIN_CATEGORY_NONE));
carla_stdout(ParameterType2Str(PARAMETER_UNKNOWN));
carla_stdout(InternalParameterIndex2Str(PARAMETER_NULL));
carla_stdout(EngineCallbackOpcode2Str(ENGINE_CALLBACK_DEBUG));
carla_stdout(EngineOption2Str(ENGINE_OPTION_DEBUG));
carla_stdout(EngineProcessMode2Str(ENGINE_PROCESS_MODE_SINGLE_CLIENT));
carla_stdout(EngineTransportMode2Str(ENGINE_TRANSPORT_MODE_INTERNAL));
carla_stdout(FileCallbackOpcode2Str(FILE_CALLBACK_DEBUG));
carla_stdout(getPluginTypeAsString(PLUGIN_INTERNAL));
carla_stdout(PatchbayIcon2Str(PATCHBAY_ICON_APPLICATION));
getPluginTypeFromString("none");
getPluginCategoryFromName("cat");
}
static void test_CarlaUtils()
{
// ----------------------------------------------------------------------------------------------------------------
// misc functions
{
bool2str(false);
bool2str(true);
pass();
char strBuf[2];
nullStrBuf(strBuf);
char* const strBuf2(strBuf+1);
nullStrBuf(strBuf2);
}
// ----------------------------------------------------------------------------------------------------------------
// string print functions
{
carla_debug("DEBUG");
carla_stdout("STDOUT %s", bool2str(true));
carla_stderr("STDERR %s", bool2str(false));
carla_stderr2("STDERR2 " P_UINT64, 0xffffffff); // 4294967295
}
// ----------------------------------------------------------------------------------------------------------------
// carla_*sleep
{
carla_sleep(1);
carla_msleep(1);
}
// ----------------------------------------------------------------------------------------------------------------
// carla_setenv
{
carla_setenv("THIS", "THAT");
assert(std::strcmp(std::getenv("THIS"), "THAT") == 0);
carla_unsetenv("THIS");
assert(std::getenv("THIS") == nullptr);
}
// ----------------------------------------------------------------------------------------------------------------
// carla_strdup
{
// with variables
const char* const str1(carla_strdup("stringN"));
const char* const strF(carla_strdup_free(strdup("stringF")));
const char* const str2(carla_strdup_safe("stringS"));
delete[] str1;
delete[] str2;
delete[] strF;
// without variables
delete[] carla_strdup("string_normal");
delete[] carla_strdup_free(strdup("string_free"));
delete[] carla_strdup_safe("string_safe");
}
{
// common use case in Carla code
struct TestStruct {
const char* strNull;
const char* strNormal;
const char* strFree;
const char* strSafe;
TestStruct()
: strNull(nullptr),
strNormal(carla_strdup("strNormal")),
strFree(carla_strdup_free(strdup("strFree"))),
strSafe(carla_strdup_safe("strSafe")) {}
~TestStruct() noexcept
{
if (strNull != nullptr)
{
delete[] strNull;
strNull = nullptr;
}
if (strNormal != nullptr)
{
delete[] strNormal;
strNormal = nullptr;
}
if (strFree != nullptr)
{
delete[] strFree;
strFree = nullptr;
}
if (strSafe != nullptr)
{
delete[] strSafe;
strSafe = nullptr;
}
}
CARLA_DECLARE_NON_COPY_STRUCT(TestStruct)
};
TestStruct a, b, c;
}
// ----------------------------------------------------------------------------------------------------------------
// memory functions
{
int a1[] = { 4, 3, 2, 1 };
int a2[] = { 4, 3, 2, 1 };
int b1[] = { 1, 2, 3, 4 };
int b2[] = { 1, 2, 3, 4 };
carla_add(a1, b1, 4);
assert(a1[0] == 5);
assert(a1[1] == 5);
assert(a1[2] == 5);
assert(a1[3] == 5);
carla_add(b1, a2, 4);
assert(b1[0] == 5);
assert(b1[1] == 5);
assert(b1[2] == 5);
assert(b1[3] == 5);
assert(a1[0] == b1[0]);
assert(a1[1] == b1[1]);
assert(a1[2] == b1[2]);
assert(a1[3] == b1[3]);
carla_copy(a1, b2, 4);
assert(a1[0] != b1[0]);
assert(a1[1] != b1[1]);
assert(a1[2] != b1[2]);
assert(a1[3] != b1[3]);
assert(a1[0] == b2[0]);
assert(a1[1] == b2[1]);
assert(a1[2] == b2[2]);
assert(a1[3] == b2[3]);
carla_copy(a1, b1, 4);
assert(a1[0] == b1[0]);
assert(a1[1] == b1[1]);
assert(a1[2] == b1[2]);
assert(a1[3] == b1[3]);
carla_copy(a1, b2, 2);
assert(a1[0] != b1[0]);
assert(a1[1] != b1[1]);
assert(a1[2] == b1[2]);
assert(a1[3] == b1[3]);
carla_copy(a1+2, b2+2, 2);
assert(a1[0] != b1[0]);
assert(a1[1] != b1[1]);
assert(a1[2] != b1[2]);
assert(a1[3] != b1[3]);
carla_copy(a1, b1, 2);
assert(a1[0] == b1[0]);
assert(a1[1] == b1[1]);
assert(a1[2] != b1[2]);
assert(a1[3] != b1[3]);
carla_copy(a1+2, b1+2, 2);
assert(a1[0] == b1[0]);
assert(a1[1] == b1[1]);
assert(a1[2] == b1[2]);
assert(a1[3] == b1[3]);
carla_fill(a1, 0, 4);
assert(a1[0] == 0);
assert(a1[1] == 0);
assert(a1[2] == 0);
assert(a1[3] == 0);
carla_fill(a1, -11, 4);
assert(a1[0] == -11);
assert(a1[1] == -11);
assert(a1[2] == -11);
assert(a1[3] == -11);
carla_fill(a1, 1791, 2);
assert(a1[0] == 1791);
assert(a1[1] == 1791);
assert(a1[2] == -11);
assert(a1[3] == -11);
carla_fill(a1+2, 1791, 2);
assert(a1[0] == 1791);
assert(a1[1] == 1791);
assert(a1[2] == 1791);
assert(a1[3] == 1791);
int16_t d = 1527, e = 0;
carla_add(&d, &d, 1);
assert(d == 1527*2);
carla_add(&d, &d, 1);
assert(d == 1527*4);
carla_add(&d, &e, 1);
assert(d == 1527*4);
assert(e == 0);
carla_add(&e, &d, 1);
assert(d == e);
carla_add(&e, &d, 1);
assert(e == d*2);
d = -e;
carla_add(&d, &e, 1);
assert(d == 0);
}
{
bool x;
const bool f = false, t = true;
carla_copy(&x, &t, 1);
assert(x);
carla_copy(&x, &f, 1);
assert(! x);
carla_fill(&x, true, 1);
assert(x);
carla_fill(&x, false, 1);
assert(! x);
}
{
uint8_t a[] = { 3, 2, 1, 0 };
carla_zeroBytes(a, 1);
assert(a[0] == 0);
assert(a[1] == 2);
assert(a[2] == 1);
assert(a[3] == 0);
carla_zeroBytes(a+1, 2);
assert(a[0] == 0);
assert(a[1] == 0);
assert(a[2] == 0);
assert(a[3] == 0);
}
{
char a[501];
for (int i=500; --i>=0;)
a[i] = 'a';
carla_zeroChars(a, 501);
for (int i=501; --i>=0;)
assert(a[i] == '\0');
for (int i=500; --i>=0;)
a[i] = 'a';
assert(std::strlen(a) == 500);
carla_fill(a+200, '\0', 1);
assert(std::strlen(a) == 200);
}
{
void* a[33];
carla_zeroPointers(a, 33);
for (int i=33; --i>=0;)
assert(a[i] == nullptr);
}
{
struct Thing {
char c;
int i;
int64_t h;
bool operator==(const Thing& t) const noexcept
{
return (t.c == c && t.i == i && t.h == h);
}
bool operator!=(const Thing& t) const noexcept
{
return !operator==(t);
}
};
Thing a, b, c;
a.c = 0;
a.i = 0;
a.h = 0;
b.c = 64;
b.i = 64;
b.h = 64;
c = a;
carla_copyStruct(a, b);
assert(a == b);
carla_zeroStruct(a);
assert(a == c);
carla_copyStruct(c, b);
assert(a != c);
// make it non-zero
a.c = 1;
Thing d[3];
carla_zeroStructs(d, 3);
assert(d[0] != a);
assert(d[1] != b);
assert(d[2] != c);
carla_copyStructs(d, &a, 1);
assert(d[0] == a);
assert(d[1] != b);
assert(d[2] != c);
carla_copyStructs(&c, d+2, 1);
assert(d[0] == a);
assert(d[1] != b);
assert(d[2] == c);
}
}
void run5Tests()
{
ushort k = 0;
MyData allMyData[MAX_RT_EVENTS];
// Make a safe copy of events while clearing them
postRtEvents.mutex.lock();
while (! postRtEvents.data.isEmpty())
{
static MyData kFallback = { { '\0' }, 0 };
const MyData& my(postRtEvents.data.getFirst(kFallback, true));
allMyData[k++] = my;
}
postRtEvents.mutex.unlock();
carla_stdout("Post-Rt Event Count: %i", k);
assert(k == 5);
// data should be empty now
assert(postRtEvents.data.count() == 0);
assert(postRtEvents.data.isEmpty());
assert(postRtEvents.dataPendingRT.count() == 0);
assert(postRtEvents.dataPendingRT.isEmpty());
// Handle events now
for (ushort i=0; i < k; ++i)
{
const MyData& my(allMyData[i]);
carla_stdout("Got data: %i %s", my.id, my.str);
}
// append events past minimum size
MyData dummyData = { { '\0' }, 0 };
// 5 initial go ok
assert(postRtEvents.dataPendingRT.append(dummyData));
assert(postRtEvents.dataPendingRT.append(dummyData));
assert(postRtEvents.dataPendingRT.append(dummyData));
assert(postRtEvents.dataPendingRT.append(dummyData));
assert(postRtEvents.dataPendingRT.append(dummyData));
// afterwards it fails
assert(! postRtEvents.dataPendingRT.append(dummyData));
assert(! postRtEvents.dataPendingRT.append(dummyData));
carla_stdout("here %i", __LINE__);
// adding sleepy works
assert(postRtEvents.dataPendingRT.append_sleepy(dummyData));
carla_stdout("here %i", __LINE__);
// now atomic works too, size was increased
assert(postRtEvents.dataPendingRT.append(dummyData));
assert(postRtEvents.dataPendingRT.append(dummyData));
assert(postRtEvents.dataPendingRT.append(dummyData));
assert(postRtEvents.dataPendingRT.append(dummyData));
carla_stdout("here %i", __LINE__);
// fails here now
assert(! postRtEvents.dataPendingRT.append(dummyData));
carla_stdout("here %i", __LINE__);
// adding sleepy still works
assert(postRtEvents.dataPendingRT.append_sleepy(dummyData));
carla_stdout("here %i", __LINE__);
// now atomic works for 1 more
assert(postRtEvents.dataPendingRT.append(dummyData));
assert(! postRtEvents.dataPendingRT.append(dummyData));
carla_stdout("here %i", __LINE__);
// and adding sleepy no longer works
assert(! postRtEvents.dataPendingRT.append_sleepy(dummyData));
carla_stdout("here %i", __LINE__);
// cleanup
postRtEvents.trySplice();
postRtEvents.clear();
}
CARLA_EXPORT
int posix_spawnp(pid_t*, const char*, const posix_spawn_file_actions_t*, const posix_spawnattr_t*, char* const[], char* const[])
{
carla_stdout("------------------------------- posix_spawnp called");
return ENOSYS;
}
int main()
{
MyData m1;
m1.id = 1;
std::strcpy(m1.str, "1");
MyData m2;
m2.id = 2;
std::strcpy(m2.str, "2");
MyData m3;
m3.id = 3;
std::strcpy(m3.str, "3");
MyData m4;
m4.id = 4;
std::strcpy(m4.str, "4");
MyData m5;
m5.id = 5;
std::strcpy(m5.str, "5");
// start
assert(postRtEvents.data.count() == 0);
assert(postRtEvents.data.isEmpty());
assert(postRtEvents.dataPendingRT.count() == 0);
assert(postRtEvents.dataPendingRT.isEmpty());
// single append
postRtEvents.appendRT(m1);
assert(postRtEvents.data.count() == 0);
assert(postRtEvents.dataPendingRT.count() == 1);
postRtEvents.trySplice();
assert(postRtEvents.data.count() == 1);
assert(postRtEvents.dataPendingRT.count() == 0);
// +3 appends
postRtEvents.appendRT(m2);
postRtEvents.appendRT(m4);
postRtEvents.appendRT(m3);
assert(postRtEvents.data.count() == 1);
assert(postRtEvents.dataPendingRT.count() == 3);
postRtEvents.trySplice();
assert(postRtEvents.data.count() == 4);
assert(postRtEvents.dataPendingRT.count() == 0);
for (RtLinkedList<MyData>::Itenerator it = postRtEvents.data.begin2(); it.valid(); it.next())
{
const MyData& my(it.getValue());
carla_stdout("FOR DATA!!!: %i %s", my.id, my.str);
if (my.id == 2)
{
// +1 append
postRtEvents.dataPendingRT.insertAt(m5, it);
assert(postRtEvents.data.count() == 4);
assert(postRtEvents.dataPendingRT.count() == 1);
}
}
for (const MyData& my : postRtEvents.data)
carla_stdout("FOR DATA!!! NEW AUTO Itenerator!!!: %i %s", my.id, my.str);
postRtEvents.trySplice();
assert(postRtEvents.data.count() == 5);
assert(postRtEvents.dataPendingRT.count() == 0);
run5Tests();
// reset
postRtEvents.clear();
assert(postRtEvents.data.count() == 0);
assert(postRtEvents.data.isEmpty());
assert(postRtEvents.dataPendingRT.count() == 0);
assert(postRtEvents.dataPendingRT.isEmpty());
// test non-rt
const unsigned int CARLA_EVENT_DATA_ATOM = 0x01;
const unsigned int CARLA_EVENT_DATA_MIDI_LL = 0x04;
LinkedList<uint32_t> evIns, evOuts;
evIns.append(CARLA_EVENT_DATA_ATOM);
evOuts.append(CARLA_EVENT_DATA_ATOM);
evOuts.append(CARLA_EVENT_DATA_MIDI_LL);
if (evIns.count() > 0)
{
for (size_t j=0, count=evIns.count(); j < count; ++j)
{
const uint32_t& type(evIns.getAt(j, 0));
if (type == CARLA_EVENT_DATA_ATOM)
pass();
else if (type == CARLA_EVENT_DATA_MIDI_LL)
pass();
}
}
evIns.clear();
evOuts.clear();
return 0;
}
static int carlaWindowMap(Display* const display, const Window window, const WindowMappingType fallbackFnType)
{
const ScopedLibOpen& slo(ScopedLibOpen::getInstance());
for (;;)
{
if (slo.winId < 0)
break;
Atom atom;
int atomFormat;
unsigned char* atomPtrs;
unsigned long numItems, ignored;
const Atom wmWindowType = XInternAtom(display, "_NET_WM_WINDOW_TYPE", False);
if (XGetWindowProperty(display, window, wmWindowType, 0, ~0L, False, AnyPropertyType,
&atom, &atomFormat, &numItems, &ignored, &atomPtrs) != Success)
{
carla_debug("carlaWindowMap(%p, %lu, %i) - XGetWindowProperty failed", display, window, fallbackFnType);
break;
}
const Atom* const atomValues = (const Atom*)atomPtrs;
bool isMainWindow = (numItems == 0);
for (ulong i=0; i<numItems; ++i)
{
const char* const atomValue(XGetAtomName(display, atomValues[i]));
CARLA_SAFE_ASSERT_CONTINUE(atomValue != nullptr && atomValue[0] != '\0');
if (std::strcmp(atomValue, "_NET_WM_WINDOW_TYPE_COMBO" ) == 0 ||
std::strcmp(atomValue, "_NET_WM_WINDOW_TYPE_DIALOG" ) == 0 ||
std::strcmp(atomValue, "_NET_WM_WINDOW_TYPE_DND" ) == 0 ||
std::strcmp(atomValue, "_NET_WM_WINDOW_TYPE_DOCK" ) == 0 ||
std::strcmp(atomValue, "_NET_WM_WINDOW_TYPE_DROPDOWN_MENU") == 0 ||
std::strcmp(atomValue, "_NET_WM_WINDOW_TYPE_MENU" ) == 0 ||
std::strcmp(atomValue, "_NET_WM_WINDOW_TYPE_NOTIFICATION" ) == 0 ||
std::strcmp(atomValue, "_NET_WM_WINDOW_TYPE_POPUP_MENU" ) == 0 ||
std::strcmp(atomValue, "_NET_WM_WINDOW_TYPE_SPLASH" ) == 0 ||
std::strcmp(atomValue, "_NET_WM_WINDOW_TYPE_TOOLBAR" ) == 0 ||
std::strcmp(atomValue, "_NET_WM_WINDOW_TYPE_TOOLTIP" ) == 0 ||
std::strcmp(atomValue, "_NET_WM_WINDOW_TYPE_UTILITY" ) == 0)
{
isMainWindow = false;
continue;
}
if (std::strcmp(atomValue, "_NET_WM_WINDOW_TYPE_NORMAL") == 0)
{
// window is good, use it if no other types are set
isMainWindow = true;
}
else
{
carla_stdout("=======================================> %s", atomValue);
}
}
if (! isMainWindow)
{
// this has always bothered me...
if (gCurrentlyMappedWindow != 0 && gCurrentWindowMapped && gCurrentWindowVisible)
XSetTransientForHint(display, window, gCurrentlyMappedWindow);
break;
}
Window transientWindow = 0;
if (XGetTransientForHint(display, window, &transientWindow) == Success && transientWindow != 0)
{
carla_stdout("Window has transient set already, ignoring it");
break;
}
// got a new window, we may need to forget last one
if (gCurrentlyMappedDisplay != nullptr && gCurrentlyMappedWindow != 0)
{
// ignore requests against the current mapped window
if (gCurrentlyMappedWindow == window)
return 0;
// we already have a mapped window, with carla visible button on, should be a dialog of sorts..
if (gCurrentWindowMapped && gCurrentWindowVisible)
{
XSetTransientForHint(display, window, gCurrentlyMappedWindow);
break;
}
// ignore empty windows created after the main one
if (numItems == 0)
break;
carla_stdout("NOTICE: XMapWindow now showing previous window");
switch (gCurrentWindowType)
{
case WindowMapNone:
break;
case WindowMapNormal:
real_XMapWindow(gCurrentlyMappedDisplay, gCurrentlyMappedWindow);
break;
case WindowMapRaised:
real_XMapRaised(gCurrentlyMappedDisplay, gCurrentlyMappedWindow);
break;
case WindowMapSubwindows:
real_XMapSubwindows(gCurrentlyMappedDisplay, gCurrentlyMappedWindow);
break;
}
}
gCurrentlyMappedDisplay = display;
gCurrentlyMappedWindow = window;
gCurrentWindowMapped = true;
gCurrentWindowType = fallbackFnType;
if (slo.winId > 0)
XSetTransientForHint(display, window, static_cast<Window>(slo.winId));
if (gCurrentWindowVisible)
{
carla_stdout("JACK application window found, showing it now");
break;
}
gCurrentWindowMapped = false;
carla_stdout("JACK application window found and captured");
return 0;
}
carla_debug("carlaWindowMap(%p, %lu, %i) - not captured", display, window, fallbackFnType);
switch (fallbackFnType)
{
case 1:
return real_XMapWindow(display, window);
case 2:
return real_XMapRaised(display, window);
case 3:
return real_XMapSubwindows(display, window);
default:
return 0;
}
}
