VuoApp.m

Go to the documentation of this file.

 
#include "module.h"
 
#include "VuoApp.h"
 
#ifndef NS_RETURNS_INNER_POINTER
#define NS_RETURNS_INNER_POINTER
#endif
#import <AppKit/AppKit.h>
#undef NS_RETURNS_INNER_POINTER
 
#include <dlfcn.h>
#include <pthread.h>
#include <libproc.h>
#include <mach-o/dyld.h>
#import <libgen.h>
#import <dirent.h>
 
#include "VuoCompositionState.h"
#include "VuoEventLoop.h"
#import "VuoAppDelegate.h"
#import "VuoAppSplashWindow.h"
 
const double VuoApp_windowFadeSeconds = 0.45;
 
bool VuoApp_isMainThread(void)
{
    static void **VuoApp_mainThread;
    static dispatch_once_t once = 0;
    dispatch_once(&once, ^{
        VuoApp_mainThread = (void **)dlsym(RTLD_SELF, "VuoApp_mainThread");
        if (!VuoApp_mainThread)
            VuoApp_mainThread = (void **)dlsym(RTLD_DEFAULT, "VuoApp_mainThread");
 
        if (!VuoApp_mainThread)
        {
            VUserLog("Error: Couldn't find VuoApp_mainThread.");
            VuoLog_backtrace();
            exit(1);
        }
 
        if (!*VuoApp_mainThread)
        {
            VUserLog("Error: VuoApp_mainThread isn't set.");
            VuoLog_backtrace();
            exit(1);
        }
    });
 
    return *VuoApp_mainThread == (void *)pthread_self();
}
 
void VuoApp_executeOnMainThread(void (^block)(void))
{
    if (!block)
        return;
 
    if (VuoApp_isMainThread())
        block();
    else
    {
        VUOLOG_PROFILE_BEGIN(mainQueue);
        dispatch_sync(dispatch_get_main_queue(), ^{
            VUOLOG_PROFILE_END(mainQueue);
            block();
        });
    }
}
 
char *VuoApp_getName(void)
{
    char **dylibPath = (char **)dlsym(RTLD_SELF, "VuoApp_dylibPath");
    if (!dylibPath)
        dylibPath = (char **)dlsym(RTLD_DEFAULT, "VuoApp_dylibPath");
    if (dylibPath)
    {
        char *filename = strrchr(*dylibPath, '/');
        if (filename)
        {
            char *name = strdup(filename + 1); // Trim leading slash.
            name[strlen(name) - strlen("-XXXXXX.dylib")] = 0;
 
            if (strcmp(name, "VuoComposition") == 0)
            {
                free(name);
                return strdup("Vuo Composition");
            }
 
            return name;
        }
    }
 
    pid_t runnerPid = VuoGetRunnerPid();
    if (runnerPid > 0)
    {
        char *runnerName = (char *)malloc(2*MAXCOMLEN);
        proc_name(runnerPid, runnerName, 2*MAXCOMLEN);
        return runnerName;
    }
 
    NSBundle *mainBundle = [NSBundle mainBundle];
    NSString *name = [mainBundle objectForInfoDictionaryKey:@"CFBundleDisplayName"];
    if (!name)
        name = [mainBundle objectForInfoDictionaryKey:@"CFBundleName"];
    if (!name)
        name = [mainBundle objectForInfoDictionaryKey:@"CFBundleExecutable"];
    if (!name)
        name = [[[mainBundle executablePath] stringByDeletingPathExtension] lastPathComponent];
 
    if (name)
        return strdup([name UTF8String]);
    else
        return strdup("");
}
 
const char *VuoApp_getVuoFrameworkPath(void)
{
    static char frameworkPath[PATH_MAX+1] = "";
    static dispatch_once_t once = 0;
    dispatch_once(&once, ^{
        uint32_t imageCount = _dyld_image_count();
        for (uint32_t i = 0; i < imageCount; ++i)
        {
            const char *dylibPath = _dyld_get_image_name(i);
            char *pos;
            if ( (pos = strstr(dylibPath, "/Vuo.framework/")) )
            {
                strncpy(frameworkPath, dylibPath, pos-dylibPath);
                break;
            }
        }
    });
    return frameworkPath;
}
 
const char *VuoApp_getVuoRunnerFrameworkPath(void)
{
    static char frameworkPath[PATH_MAX+1] = "";
    static dispatch_once_t once = 0;
    dispatch_once(&once, ^{
        uint32_t imageCount = _dyld_image_count();
        for (uint32_t i = 0; i < imageCount; ++i)
        {
            const char *dylibPath = _dyld_get_image_name(i);
            char *pos;
            if ( (pos = strstr(dylibPath, "/VuoRunner.framework/")) )
            {
                strncpy(frameworkPath, dylibPath, pos-dylibPath);
                break;
            }
        }
    });
    return frameworkPath;
}
 
static void VuoApp_initNSApplication(bool requiresDockIcon)
{
    NSAutoreleasePool *pool = [NSAutoreleasePool new];
 
    // https://stackoverflow.com/a/11010614/238387
    NSApplication *app = [NSApplication sharedApplication];
 
    if (![app delegate])
        [app setDelegate:[VuoAppDelegate new]];
 
    // When there's no host app present,
    // create the default menu with the About and Quit menu items,
    // to be overridden if/when any windows get focus.
    VuoApp_setMenuItems(NULL);
 
    [app setActivationPolicy:requiresDockIcon ? NSApplicationActivationPolicyRegular : NSApplicationActivationPolicyAccessory];
 
    // Stop bouncing in the dock.
    [app finishLaunching];
 
    VuoEventLoop_switchToAppMode();
 
    if (VuoShouldShowSplashWindow())
        VuoApp_showSplashWindow();
 
    [pool drain];
}
 
#ifndef DOXYGEN
void VuoApp_fini(void);
#endif
 
void VuoApp_init(bool requiresDockIcon)
{
    if (NSApp)
    {
        VuoApp_executeOnMainThread(^{
            if (requiresDockIcon
             && NSApplication.sharedApplication.activationPolicy != NSApplicationActivationPolicyRegular)
                [NSApp setActivationPolicy:NSApplicationActivationPolicyRegular];
        });
        return;
    }
 
    static dispatch_once_t once = 0;
    dispatch_once(&once, ^{
        VuoApp_executeOnMainThread(^{
            VuoApp_initNSApplication(requiresDockIcon);
        });
        VuoAddCompositionFiniCallback(VuoApp_fini);
    });
}
 
static void VuoApp_finiWindows(uint64_t compositionUid)
{
    SEL stopRecording = @selector(stopRecording);
    SEL compositionUidSel = @selector(compositionUid);
    for (NSWindow *window in [NSApp windows])
        // Stop any window recordings currently in progress.
        // This prompts the user for the save destination,
        // so make sure these complete before shutting the composition down.
        if ([window respondsToSelector:stopRecording]
         && [window respondsToSelector:compositionUidSel]
         && (uint64_t)[window performSelector:compositionUidSel] == compositionUid)
            [window performSelector:stopRecording];
 
    if ([NSApp windows].count)
    {
        // Animate removing the app from the dock while the window is fading out (instead of waiting until after).
        [NSApp setActivationPolicy:NSApplicationActivationPolicyProhibited];
 
        double fudge = .1; // Wait a little longer, to ensure the animation's completionHandler gets called.
        [NSRunLoop.currentRunLoop runUntilDate:[NSDate dateWithTimeIntervalSinceNow:VuoApp_windowFadeSeconds + fudge]];
    }
 
    // Avoid leaving menubar remnants behind.
    // https://b33p.net/kosada/node/13384
    [NSApp hide:nil];
}
 
void VuoApp_fini(void)
{
    if (!NSApp)
        return;
 
    void *compositionState = vuoCopyCompositionStateFromThreadLocalStorage();
    uint64_t compositionUid = vuoGetCompositionUniqueIdentifier(compositionState);
    free(compositionState);
 
    if (VuoApp_isMainThread())
        VuoApp_finiWindows(compositionUid);
    else
    {
        VUOLOG_PROFILE_BEGIN(mainQueue);
        dispatch_sync(dispatch_get_main_queue(), ^{
            VUOLOG_PROFILE_END(mainQueue);
            VuoApp_finiWindows(compositionUid);
        });
    }
}