VuoWindow.m

Go to the documentation of this file.

 
#import "VuoWindow.h"
#import "VuoWindowTextInternal.h"
#import "VuoGraphicsWindow.h"
#include "VuoEventLoop.h"
#include "VuoCompositionState.h"
#include "VuoApp.h"
#import "VuoAppSplashWindow.h"
 
#include "module.h"
 
#ifdef VUO_COMPILER
VuoModuleMetadata({
                     "title" : "VuoWindow",
                     "dependencies" : [
                         "AppKit.framework",
                         "VuoGraphicsWindow",
                         "VuoWindowTextInternal"
                     ]
                 });
#endif
 
void VuoWindowText_destroy(VuoWindowText w);
 
VuoWindowText VuoWindowText_make(void)
{
    void *compositionState = vuoCopyCompositionStateFromThreadLocalStorage();
 
    __block VuoWindowTextInternal *window = NULL;
    VUOLOG_PROFILE_BEGIN(mainQueue);
    dispatch_sync(dispatch_get_main_queue(), ^{
                      VUOLOG_PROFILE_END(mainQueue);
                      vuoAddCompositionStateToThreadLocalStorage(compositionState);
 
                      VuoApp_init(true);
                      window = [[VuoWindowTextInternal alloc] init];
 
                      window.alphaValue = 0;
                      if (VuoApp_splashWindow)
                          [window orderWindow:NSWindowBelow relativeTo:VuoApp_splashWindow.windowNumber];
                      else
                          [window orderFront:NSApp];
                      [window makeKeyWindow];
 
                      [NSAnimationContext runAnimationGroup:^(NSAnimationContext *context){
                          context.duration = VuoApp_windowFadeSeconds;
                          window.animator.alphaValue = 1;
                      } completionHandler:^{}];
 
                      vuoRemoveCompositionStateFromThreadLocalStorage();
                      free(compositionState);
                   });
    VuoRegister(window, VuoWindowText_destroy);
    return (VuoWindowText *)window;
}
 
void VuoWindowText_enableTriggers
(
        VuoWindowText w,
        VuoOutputTrigger(typedLine, VuoText),
        VuoOutputTrigger(typedWord, VuoText),
        VuoOutputTrigger(typedCharacter, VuoText)
)
{
    VuoWindowTextInternal *window = (VuoWindowTextInternal *)w;
    VUOLOG_PROFILE_BEGIN(mainQueue);
    dispatch_sync(dispatch_get_main_queue(), ^{
                      VUOLOG_PROFILE_END(mainQueue);
                      [window enableTriggersWithTypedLine:typedLine typedWord:typedWord typedCharacter:typedCharacter];
                  });
}
 
void VuoWindowText_disableTriggers(VuoWindowText w)
{
    VuoWindowTextInternal *window = (VuoWindowTextInternal *)w;
    VUOLOG_PROFILE_BEGIN(mainQueue);
    dispatch_sync(dispatch_get_main_queue(), ^{
                      VUOLOG_PROFILE_END(mainQueue);
                      [window disableTriggers];
                  });
}
 
void VuoWindowText_appendLine(VuoWindowText vw, const char *text)
{
    VuoWindowTextInternal *window = (VuoWindowTextInternal *)vw;
    char *textCopy = text ? strdup(text) : strdup("");  // ... in case the caller frees text before the asynchronous block uses it.
    VUOLOG_PROFILE_BEGIN(mainQueue);
    dispatch_async(dispatch_get_main_queue(), ^{
                       VUOLOG_PROFILE_END(mainQueue);
                       [window appendLine:textCopy];
                       free(textCopy);
                   });
}
 
void VuoWindowText_close(VuoWindowText vw)
{
    VuoWindowTextInternal *window = (VuoWindowTextInternal *)vw;
    VuoRetain(window);
    VUOLOG_PROFILE_BEGIN(mainQueue);
    dispatch_sync(dispatch_get_main_queue(), ^{
                      VUOLOG_PROFILE_END(mainQueue);
 
                      void (^completionHandler)(void) = ^{
                          [window close];
                          VuoRelease(window);
                      };
 
                      // When fullscreen, macOS performs its own close animation, so only apply our fade-out animation when windowed.
                      if (window.styleMask & NSFullScreenWindowMask)
                          completionHandler();
                      else
                          [NSAnimationContext runAnimationGroup:^(NSAnimationContext *context){
                              context.duration = VuoApp_windowFadeSeconds;
                              window.animator.alphaValue = 0;
                          } completionHandler:completionHandler];
                  });
}
 
void VuoWindowText_destroy(VuoWindowText vw)
{
    VuoWindowTextInternal *window = (VuoWindowTextInternal *)vw;
    VuoApp_executeOnMainThread(^{
        [window release];
    });
}
 
 
void VuoWindowOpenGl_destroy(VuoWindowOpenGl w);
 
VuoWindowOpenGl VuoWindowOpenGl_make
(
        void (*initCallback)(void *, float backingScaleFactor),
        void (*updateBackingCallback)(void *, float backingScaleFactor),
        void (*resizeCallback)(void *, unsigned int, unsigned int),
        VuoIoSurface (*drawCallback)(void *),
        void *context
)
{
    __block VuoGraphicsWindow *window = NULL;
    void *compositionState = vuoCopyCompositionStateFromThreadLocalStorage();
 
    VUOLOG_PROFILE_BEGIN(mainQueue);
    dispatch_sync(dispatch_get_main_queue(), ^{
                      VUOLOG_PROFILE_END(mainQueue);
                      vuoAddCompositionStateToThreadLocalStorage(compositionState);
 
                      VuoApp_init(true);
                      window = [[VuoGraphicsWindow alloc] initWithInitCallback:initCallback
                                                         updateBackingCallback:updateBackingCallback
                                                                resizeCallback:resizeCallback
                                                                  drawCallback:drawCallback
                                                                      userData:context];
                      window.compositionUid = vuoGetCompositionUniqueIdentifier(compositionState);
 
                      window.alphaValue = 0;
                      if (VuoApp_splashWindow)
                          [window orderWindow:NSWindowBelow relativeTo:VuoApp_splashWindow.windowNumber];
                      else
                          [window orderFront:NSApp];
                      [window makeKeyWindow];
 
                      [NSAnimationContext runAnimationGroup:^(NSAnimationContext *context){
                          context.duration = VuoApp_windowFadeSeconds;
                          window.animator.alphaValue = 1;
                      } completionHandler:^{}];
 
                      vuoRemoveCompositionStateFromThreadLocalStorage();
                      free(compositionState);
                  });
    VuoRegister(window, VuoWindowOpenGl_destroy);
    return (VuoWindowOpenGl *)window;
}
 
void VuoWindowOpenGl_enableTriggers
(
        VuoWindowOpenGl w,
        VuoOutputTrigger(updatedWindow, VuoRenderedLayers)
)
{
    VuoGraphicsWindow *window = (VuoGraphicsWindow *)w;
    [window enableUpdatedWindowTrigger:updatedWindow];
}
 
void VuoWindowOpenGl_enableTriggers_deprecated
(
        VuoWindowOpenGl w,
        VuoOutputTrigger(showedWindow, VuoWindowReference),
        VuoOutputTrigger(requestedFrame, VuoReal)
)
{
    VuoGraphicsWindow *window = (VuoGraphicsWindow *)w;
    [window enableShowedWindowTrigger:showedWindow requestedFrameTrigger:requestedFrame];
}
 
void VuoWindowOpenGl_disableTriggers(VuoWindowOpenGl w)
{
    VuoGraphicsWindow *window = (VuoGraphicsWindow *)w;
    [window disableTriggers];
}
 
void VuoWindowOpenGl_redraw(VuoWindowOpenGl w)
{
    VuoGraphicsWindow *window = (VuoGraphicsWindow *)w;
    [window draw];
}
 
void VuoWindowOpenGl_setProperties(VuoWindowOpenGl w, VuoList_VuoWindowProperty properties)
{
    VuoGraphicsWindow *window = (VuoGraphicsWindow *)w;
    VUOLOG_PROFILE_BEGIN(mainQueue);
    dispatch_sync(dispatch_get_main_queue(), ^{
                      VUOLOG_PROFILE_END(mainQueue);
                      [window setProperties:properties];
                  });
}
 
void VuoWindowOpenGl_setAspectRatio(VuoWindowOpenGl w, unsigned int pixelsWide, unsigned int pixelsHigh)
{
    VuoGraphicsWindow *window = (VuoGraphicsWindow *)w;
    VUOLOG_PROFILE_BEGIN(mainQueue);
    dispatch_async(dispatch_get_main_queue(), ^{
                       VUOLOG_PROFILE_END(mainQueue);
                       [window setAspectRatioToWidth:pixelsWide height:pixelsHigh];
                   });
}
 
void VuoWindowOpenGl_unlockAspectRatio(VuoWindowOpenGl w)
{
    VuoGraphicsWindow *window = (VuoGraphicsWindow *)w;
    VUOLOG_PROFILE_BEGIN(mainQueue);
    dispatch_async(dispatch_get_main_queue(), ^{
                       VUOLOG_PROFILE_END(mainQueue);
                       [window unlockAspectRatio];
                   });
}
 
void VuoWindowOpenGl_close(VuoWindowOpenGl vw, void (^closedHandler)(void))
{
    VuoGraphicsWindow *window = (VuoGraphicsWindow *)vw;
    VuoRetain(window);
    VUOLOG_PROFILE_BEGIN(mainQueue);
    dispatch_sync(dispatch_get_main_queue(), ^{
                      VUOLOG_PROFILE_END(mainQueue);
 
                      void (^completionHandler)(void) = ^{
                          [window close];
                          VuoRelease(window);
                          closedHandler();
                      };
 
                      // When fullscreen, macOS performs its own close animation, so only apply our fade-out animation when windowed.
                      if (window.isFullScreen)
                          completionHandler();
                      else
                          [NSAnimationContext runAnimationGroup:^(NSAnimationContext *context){
                              context.duration = VuoApp_windowFadeSeconds;
                              window.animator.alphaValue = 0;
                          } completionHandler:completionHandler];
                  });
}
 
void VuoWindowOpenGl_destroy(VuoWindowOpenGl vw)
{
    VuoGraphicsWindow *window = (VuoGraphicsWindow *)vw;
    VuoApp_executeOnMainThread(^{
        [window release];
    });
}