X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Fau_pluginui.mm;h=1a80837acfa2e117703fe69051df2d182a4beb3a;hb=154f9825ff72d691ba550de573948424b81a09a6;hp=51f73199f75bd045436b2904ce1fa8d2dfd4fb44;hpb=bb457bb960c5bd7ed538f9d31477293415739f68;p=ardour.git diff --git a/gtk2_ardour/au_pluginui.mm b/gtk2_ardour/au_pluginui.mm index 51f73199f7..1a80837acf 100644 --- a/gtk2_ardour/au_pluginui.mm +++ b/gtk2_ardour/au_pluginui.mm @@ -1,85 +1,537 @@ -#include -#include -#include +#undef Marker +#define Marker FuckYouAppleAndYourLackOfNameSpaces +#include +#include +#include #include +#include "pbd/convert.h" +#include "pbd/error.h" + +#include "ardour/audio_unit.h" +#include "ardour/debug.h" +#include "ardour/plugin_insert.h" + +#undef check // stupid gtk, stupid apple + +#include +#include + #include "au_pluginui.h" #include "gui_thread.h" +#include "processor_box.h" + +// yes, yes we know (see wscript for various available OSX compat modes) +#if defined (__clang__) +# pragma clang diagnostic push +# pragma clang diagnostic ignored "-Wdeprecated-declarations" +#endif + +#include "CAAudioUnit.h" +#include "CAComponent.h" -#include -#include +#if defined (__clang__) +# pragma clang diagnostic pop +#endif #import #import +#import + +#ifndef __ppc__ +#include +#endif -#include "i18n.h" +#undef Marker +#include "keyboard.h" +#include "utils.h" +#include "public_editor.h" +#include "pbd/i18n.h" + +#include "gtk2ardour-config.h" + +#ifdef COREAUDIO105 +#define ArdourCloseComponent CloseComponent +#else +#define ArdourCloseComponent AudioComponentInstanceDispose +#endif using namespace ARDOUR; using namespace Gtk; -using namespace sigc; +using namespace Gtkmm2ext; using namespace std; using namespace PBD; -static const float kOffsetForAUView_X = 220; -static const float kOffsetForAUView_Y = 90; +vector AUPluginUI::automation_mode_strings; +int64_t AUPluginUI::last_timer = 0; +bool AUPluginUI::timer_needed = true; +CFRunLoopTimerRef AUPluginUI::cf_timer; +sigc::connection AUPluginUI::timer_connection; + +static const gchar* _automation_mode_strings[] = { + X_("Manual"), + X_("Play"), + X_("Write"), + X_("Touch"), + 0 +}; + +static void +dump_view_tree (NSView* view, int depth, int maxdepth) +{ + NSArray* subviews = [view subviews]; + unsigned long cnt = [subviews count]; + + if (depth == 0) { + NSView* su = [view superview]; + if (su) { + NSRect sf = [su frame]; + cerr << " PARENT view " << su << " @ " << sf.origin.x << ", " << sf.origin.y + << ' ' << sf.size.width << " x " << sf.size.height + << endl; + } + } + + for (int d = 0; d < depth; d++) { + cerr << '\t'; + } + NSRect frame = [view frame]; + cerr << " view " << view << " @ " << frame.origin.x << ", " << frame.origin.y + << ' ' << frame.size.width << " x " << frame.size.height + << endl; + + if (depth >= maxdepth) { + return; + } + for (unsigned long i = 0; i < cnt; ++i) { + NSView* subview = [subviews objectAtIndex:i]; + dump_view_tree (subview, depth+1, maxdepth); + } +} + +/* This deeply hacky block of code exists for a rather convoluted reason. + * + * The proximal reason is that there are plugins (such as XLN's Addictive Drums + * 2) which redraw their GUI/editor windows using a timer, and use a drawing + * technique that on Retina displays ends up calling arg32_image_mark_RGB32, a + * function that for some reason (probably byte-swapping or pixel-doubling) is + * many times slower than the function used on non-Retina displays. + * + * We are not the first people to discover the problem with + * arg32_image_mark_RGB32. + * + * Justin Fraenkel, the lead author of Reaper, wrote a very detailed account of + * the performance issues with arg32_image_mark_RGB32 here: + * http://www.1014.org/?article=516 + * + * The problem was also seen by Robert O'Callahan (lead developer of rr, the + * reverse debugger) as far back as 2010: + * http://robert.ocallahan.org/2010/05/cglayer-performance-trap-with-isflipped_03.html + * + * In fact, it is so slow that the drawing takes up close to 100% of a single + * core, and the event loop that the drawing occurs in never sleeps or "idles". + * + * In AU hosts built directly on top of Cocoa, or some other toolkits, this + * isn't inherently a major problem - it just makes the entire GUI of the + * application slow. + * + * However, there is an additional problem for Ardour because GTK+ is built on + * top of the GDK/Quartz event loop integration. This integration is rather + * baroque, mostly because it was written at a time when CFRunLoop did not + * offer a way to wait for "input" from file descriptors (which arrived in OS X + * 10.5). As a result, it uses a hair-raising design involving an additional + * thread. This design has a major problem, which is that it effectively + * creates two nested run loops. + * + * The GTK+/GDK/glib one runs until it has nothing to do, at which time it + * calls a function to wait until there is something to do. On Linux or Windows + * that would involve some variant or relative of poll(2), which puts the + * process to sleep until there is something to do. + * + * On OS X, glib ends up calling [CFRunLoop waitForNextEventMatchingMask] which + * will eventually put the process to sleep, but won't do so until the + * CFRunLoop also has nothing to do. This includes (at least) a complete redraw + * cycle. If redrawing takes too long, and there are timers expired for another + * redraw (e.g. Addictive Drums 2, again), then the CFRunLoop will just start + * another redraw cycle after processing any events and other stuff. + * + * If the CFRunLoop stays busy, then it will never return to the glib + * level at all, thus stopping any further GTK+ level activity (events, + * drawing) from taking place. In short, the current (spring 2016) design of + * the GDK/Quartz event loop integration relies on the idea that the internal + * CFRunLoop will go idle, and totally breaks if this does not happen. + * + * So take a fully functional Ardour, add in XLN's Addictive Drums 2, and a + * Retina display, and Apple's ridiculously slow blitting code, and the + * CFRunLoop never goes idle. As soon as Addictive Drums starts drawing (over + * and over again), the GTK+ event loop stops receiving events and stops + * drawing. + * + * One fix for this was to run a nested GTK+ event loop iteration (or two) + * whenever a plugin window was redrawn. This works in the sense that the + * immediate issue (no GTK+ events or drawing) is fixed. But the recursive GTK+ + * event loop causes its own (very subtle) problems too. + * + * This code takes a rather radical approach. We use Objective C's ability to + * swizzle object methods. Specifically, we replace [NSView displayIfNeeded] + * with our own version which will skip redraws of plugin windows if we tell it + * too. If we haven't done that, or if the redraw is of a non-plugin window, + * then we invoke the original displayIfNeeded method. + * + * After every 10 redraws of a given plugin GUI/editor window, we queue up a + * GTK/glib idle callback to measure the interval between those idle + * callbacks. We do this globally across all plugin windows, so if the callback + * is already queued, we don't requeue it. + * + * If the interval is longer than 40msec (a 25fps redraw rate), we set + * block_plugin_redraws to some number. Each successive call to our interposed + * displayIfNeeded method will (a) check this value and if non-zero (b) check + * if the call is for a plugin-related NSView/NSWindow. If it is, then we will + * skip the redisplay entirely, hopefully avoiding any calls to + * argb32_image_mark_RGB32 or any other slow drawing code, and thus allowing + * the CFRunLoop to go idle. If the value is zero or the call is for a + * non-plugin window, then we just invoke the "original" displayIfNeeded + * method. + * + * This hack adds a tiny bit of overhead onto redrawing of the entire + * application. But in the common case this consists of 1 conditional (the + * check on block_plugin_redraws, which will find it to be zero) and the + * invocation of the original method. Given how much work is typically done + * during drawing, this seems acceptable. + * + * The correct fix for this is to redesign the relationship between + * GTK+/GDK/glib so that a glib run loop is actually a CFRunLoop, with all + * GSources represented as CFRunLoopSources, without any nesting and without + * any additional thread. This is not a task to be undertaken lightly, and is + * certainly substantially more work than this was. It may never be possible to + * do that work in a way that could be integrated back into glib, because of + * the rather specific semantics and types of GSources, but it would almost + * certainly be possible to make it work for Ardour. + */ + +static uint32_t block_plugin_redraws = 0; +static const uint32_t minimum_redraw_rate = 30; /* frames per second */ +static const uint32_t block_plugin_redraw_count = 15; /* number of combined plugin redraws to block, if blocking */ + +#ifdef __ppc__ + +/* PowerPC versions of OS X do not support libdispatch, which we use below when swizzling objective C. But they also don't have Retina + * which is the underlying reason for this code. So just skip it on those CPUs. + */ + + +static void add_plugin_view (id view) {} +static void remove_plugin_view (id view) {} + +#else + +static IMP original_nsview_drawIfNeeded; +static std::vector plugin_views; + +static void add_plugin_view (id view) +{ + if (plugin_views.empty()) { + AUPluginUI::start_cf_timer (); + } + + plugin_views.push_back (view); + +} + +static void remove_plugin_view (id view) +{ + std::vector::iterator x = find (plugin_views.begin(), plugin_views.end(), view); + if (x != plugin_views.end()) { + plugin_views.erase (x); + } + if (plugin_views.empty()) { + AUPluginUI::stop_cf_timer (); + } +} + +static void interposed_drawIfNeeded (id receiver, SEL selector, NSRect rect) +{ + if (block_plugin_redraws && (find (plugin_views.begin(), plugin_views.end(), receiver) != plugin_views.end())) { + block_plugin_redraws--; +#ifdef AU_DEBUG_PRINT + std::cerr << "Plugin redraw blocked\n"; +#endif + /* YOU ... SHALL .... NOT ... DRAW!!!! */ + return; + } + (void) ((int (*)(id,SEL,NSRect)) original_nsview_drawIfNeeded) (receiver, selector, rect); +} + +@implementation NSView (Tracking) ++ (void) load { + static dispatch_once_t once_token; + + /* this swizzles NSView::displayIfNeeded and replaces it with + * interposed_drawIfNeeded(), which allows us to interpose and block + * the redrawing of plugin UIs when their redrawing behaviour + * is interfering with event loop behaviour. + */ + + dispatch_once (&once_token, ^{ + Method target = class_getInstanceMethod ([NSView class], @selector(displayIfNeeded)); + original_nsview_drawIfNeeded = method_setImplementation (target, (IMP) interposed_drawIfNeeded); + }); +} + +@end + +#endif /* __ppc__ */ + +/* END OF THE PLUGIN REDRAW HACK */ + +@implementation NotificationObject + +- (NotificationObject*) initWithPluginUI: (AUPluginUI*) apluginui andCocoaParent: (NSWindow*) cp andTopLevelParent: (NSWindow*) tlp +{ + self = [ super init ]; + + if (self) { + plugin_ui = apluginui; + top_level_parent = tlp; + + if (cp) { + cocoa_parent = cp; + + [[NSNotificationCenter defaultCenter] + addObserver:self + selector:@selector(cocoaParentActivationHandler:) + name:NSWindowDidBecomeMainNotification + object:NULL]; + + [[NSNotificationCenter defaultCenter] + addObserver:self + selector:@selector(cocoaParentBecameKeyHandler:) + name:NSWindowDidBecomeKeyNotification + object:NULL]; + } + } + + return self; +} + +- (void)cocoaParentActivationHandler:(NSNotification *)notification +{ + NSWindow* notification_window = (NSWindow *)[notification object]; + + if (top_level_parent == notification_window || cocoa_parent == notification_window) { + if ([notification_window isMainWindow]) { + plugin_ui->activate(); + } else { + plugin_ui->deactivate(); + } + } +} + +- (void)cocoaParentBecameKeyHandler:(NSNotification *)notification +{ + NSWindow* notification_window = (NSWindow *)[notification object]; + + if (top_level_parent == notification_window || cocoa_parent == notification_window) { + if ([notification_window isKeyWindow]) { + plugin_ui->activate(); + } else { + plugin_ui->deactivate(); + } + } +} + +- (void)auViewResized:(NSNotification *)notification +{ + (void) notification; // stop complaints about unusued argument + plugin_ui->cocoa_view_resized(); +} + +@end + +@implementation LiveResizeNotificationObject + +- (LiveResizeNotificationObject*) initWithPluginUI: (AUPluginUI*) apluginui +{ + self = [ super init ]; + if (self) { + plugin_ui = apluginui; + } + + return self; +} + +- (void)windowWillStartLiveResizeHandler:(NSNotification*)notification +{ + plugin_ui->start_live_resize (); +} + +- (void)windowWillEndLiveResizeHandler:(NSNotification*)notification +{ + plugin_ui->end_live_resize (); +} +@end AUPluginUI::AUPluginUI (boost::shared_ptr insert) : PlugUIBase (insert) + , automation_mode_label (_("Automation")) + , preset_label (_("Presets")) + , resizable (false) + , req_width (0) + , req_height (0) + , cocoa_window (0) + , au_view (0) + , in_live_resize (false) + , plugin_requested_resize (0) + , cocoa_parent (0) + , _notify (0) + , _resize_notify (0) { + if (automation_mode_strings.empty()) { + automation_mode_strings = I18N (_automation_mode_strings); + } + + set_popdown_strings (automation_mode_selector, automation_mode_strings); + automation_mode_selector.set_active_text (automation_mode_strings.front()); + if ((au = boost::dynamic_pointer_cast (insert->plugin())) == 0) { error << _("unknown type of editor-supplying plugin (note: no AudioUnit support in this version of ardour)") << endmsg; throw failed_constructor (); } - bool has_carbon; - bool has_cocoa; + /* stuff some stuff into the top of the window */ + + HBox* smaller_hbox = manage (new HBox); + + smaller_hbox->set_spacing (6); + smaller_hbox->pack_start (pin_management_button, false, false, 4); + smaller_hbox->pack_start (preset_label, false, false, 4); + smaller_hbox->pack_start (_preset_modified, false, false); + smaller_hbox->pack_start (_preset_combo, false, false); + smaller_hbox->pack_start (add_button, false, false); + smaller_hbox->pack_start (save_button, false, false); + smaller_hbox->pack_start (delete_button, false, false); + +#if 0 + /* one day these might be useful with an AU plugin, but not yet */ + smaller_hbox->pack_start (automation_mode_label, false, false); + smaller_hbox->pack_start (automation_mode_selector, false, false); +#endif + if (insert->controls().size() > 0) { + smaller_hbox->pack_start (reset_button, false, false); + } + smaller_hbox->pack_start (bypass_button, false, true); + + VBox* v1_box = manage (new VBox); + VBox* v2_box = manage (new VBox); + + v1_box->pack_start (*smaller_hbox, false, true); + v2_box->pack_start (focus_button, false, true); + + top_box.set_homogeneous (false); + top_box.set_spacing (6); + top_box.set_border_width (6); + + top_box.pack_end (*v2_box, false, false); + top_box.pack_end (*v1_box, false, false); + + set_spacing (6); + pack_start (top_box, false, false); + pack_start (low_box, true, true); + + preset_label.show (); + _preset_combo.show (); + automation_mode_label.show (); + automation_mode_selector.show (); + bypass_button.show (); + top_box.show (); + low_box.show (); - carbon_parented = false; - cocoa_parented = false; cocoa_parent = 0; cocoa_window = 0; - test_view_support (has_carbon, has_cocoa); +#ifdef WITH_CARBON + _activating_from_app = false; + _notify = 0; + au_view = 0; + editView = 0; + carbon_window = 0; +#endif + + /* prefer cocoa, fall back to cocoa, but use carbon if its there */ - if (has_cocoa) { + if (test_cocoa_view_support()) { create_cocoa_view (); - } else if (has_carbon) { - create_carbon_view (has_carbon); +#ifdef WITH_CARBON + } else if (test_carbon_view_support()) { + create_carbon_view (); +#endif } else { - /* fallback to cocoa */ create_cocoa_view (); } -} + low_box.add_events (Gdk::VISIBILITY_NOTIFY_MASK | Gdk::EXPOSURE_MASK); + + low_box.signal_realize().connect (mem_fun (this, &AUPluginUI::lower_box_realized)); + low_box.signal_visibility_notify_event ().connect (mem_fun (this, &AUPluginUI::lower_box_visibility_notify)); + if (au_view) { + low_box.signal_size_request ().connect (mem_fun (this, &AUPluginUI::lower_box_size_request)); + low_box.signal_size_allocate ().connect (mem_fun (this, &AUPluginUI::lower_box_size_allocate)); + low_box.signal_map ().connect (mem_fun (this, &AUPluginUI::lower_box_map)); + low_box.signal_unmap ().connect (mem_fun (this, &AUPluginUI::lower_box_unmap)); + } +} AUPluginUI::~AUPluginUI () { - if (carbon_parented) { - NSWindow* win = get_nswindow(); - RemoveEventHandler(carbon_event_handler); + if (_notify) { + [[NSNotificationCenter defaultCenter] removeObserver:_notify]; + } + + if (_resize_notify) { + [[NSNotificationCenter defaultCenter] removeObserver:_resize_notify]; + } + + NSWindow* win = get_nswindow(); + if (au_view) { + remove_plugin_view ([[win contentView] superview]); + } + +#ifdef WITH_CARBON + if (cocoa_parent) { [win removeChildWindow:cocoa_parent]; } -} -void -AUPluginUI::test_view_support (bool& has_carbon, bool& has_cocoa) -{ - has_carbon = test_carbon_view_support(); - has_cocoa = test_cocoa_view_support(); + if (carbon_window) { + /* not parented, just overlaid on top of our window */ + DisposeWindow (carbon_window); + } +#endif + + if (editView) { + ArdourCloseComponent (editView); + } + + if (au_view) { + /* remove whatever we packed into low_box so that GTK doesn't + mess with it. + */ + [au_view removeFromSuperview]; + } } bool AUPluginUI::test_carbon_view_support () { +#ifdef WITH_CARBON bool ret = false; - + carbon_descriptor.componentType = kAudioUnitCarbonViewComponentType; carbon_descriptor.componentSubType = 'gnrc'; carbon_descriptor.componentManufacturer = 'appl'; carbon_descriptor.componentFlags = 0; carbon_descriptor.componentFlagsMask = 0; - + OSStatus err; // ask the AU for its first editor component @@ -98,8 +550,11 @@ AUPluginUI::test_carbon_view_support () } return ret; +#else + return false; +#endif } - + bool AUPluginUI::test_cocoa_view_support () { @@ -108,7 +563,7 @@ AUPluginUI::test_cocoa_view_support () OSStatus err = AudioUnitGetPropertyInfo(*au->get_au(), kAudioUnitProperty_CocoaUI, kAudioUnitScope_Global, 0, &dataSize, &isWritable); - + return dataSize > 0 && err == noErr; } @@ -127,27 +582,32 @@ AUPluginUI::plugin_class_valid (Class pluginClass) int AUPluginUI::create_cocoa_view () { - BOOL wasAbleToLoadCustomView = NO; + bool wasAbleToLoadCustomView = false; AudioUnitCocoaViewInfo* cocoaViewInfo = NULL; UInt32 numberOfClasses = 0; UInt32 dataSize; Boolean isWritable; NSString* factoryClassName = 0; - NSURL* CocoaViewBundlePath; + NSURL* CocoaViewBundlePath = NULL; OSStatus result = AudioUnitGetPropertyInfo (*au->get_au(), kAudioUnitProperty_CocoaUI, - kAudioUnitScope_Global, + kAudioUnitScope_Global, 0, &dataSize, &isWritable ); numberOfClasses = (dataSize - sizeof(CFURLRef)) / sizeof(CFStringRef); - + // Does view have custom Cocoa UI? - + if ((result == noErr) && (numberOfClasses > 0) ) { + + DEBUG_TRACE(DEBUG::AudioUnits, + string_compose ( "based on %1, there are %2 cocoa UI classes\n", dataSize, numberOfClasses)); + cocoaViewInfo = (AudioUnitCocoaViewInfo *)malloc(dataSize); + if(AudioUnitGetProperty(*au->get_au(), kAudioUnitProperty_CocoaUI, kAudioUnitScope_Global, @@ -156,12 +616,17 @@ AUPluginUI::create_cocoa_view () &dataSize) == noErr) { CocoaViewBundlePath = (NSURL *)cocoaViewInfo->mCocoaAUViewBundleLocation; - + // we only take the first view in this example. factoryClassName = (NSString *)cocoaViewInfo->mCocoaAUViewClass[0]; + DEBUG_TRACE (DEBUG::AudioUnits, string_compose ("the factory name is %1 bundle is %2\n", + [factoryClassName UTF8String], CocoaViewBundlePath)); + } else { + DEBUG_TRACE (DEBUG::AudioUnits, string_compose ("No cocoaUI property cocoaViewInfo = %1\n", cocoaViewInfo)); + if (cocoaViewInfo != NULL) { free (cocoaViewInfo); cocoaViewInfo = NULL; @@ -169,94 +634,309 @@ AUPluginUI::create_cocoa_view () } } - NSRect crect = { { 0, 0 }, { 1, 1} }; - // [A] Show custom UI if view has it if (CocoaViewBundlePath && factoryClassName) { - NSBundle *viewBundle = [NSBundle bundleWithPath:[CocoaViewBundlePath path]]; - if (viewBundle == nil) { + NSBundle *viewBundle = [NSBundle bundleWithPath:[CocoaViewBundlePath path]]; + + DEBUG_TRACE (DEBUG::AudioUnits, string_compose ("tried to create bundle, result = %1\n", viewBundle)); + + if (viewBundle == NULL) { error << _("AUPluginUI: error loading AU view's bundle") << endmsg; return -1; } else { Class factoryClass = [viewBundle classNamed:factoryClassName]; + DEBUG_TRACE (DEBUG::AudioUnits, string_compose ("tried to create factory class, result = %1\n", factoryClass)); if (!factoryClass) { error << _("AUPluginUI: error getting AU view's factory class from bundle") << endmsg; return -1; } - + // make sure 'factoryClass' implements the AUCocoaUIBase protocol if (!plugin_class_valid (factoryClass)) { error << _("AUPluginUI: U view's factory class does not properly implement the AUCocoaUIBase protocol") << endmsg; return -1; } // make a factory - id factoryInstance = [[[factoryClass alloc] init] autorelease]; - if (factoryInstance == nil) { + id factory = [[[factoryClass alloc] init] autorelease]; + if (factory == NULL) { error << _("AUPluginUI: Could not create an instance of the AU view factory") << endmsg; return -1; } + DEBUG_TRACE (DEBUG::AudioUnits, "got a factory instance\n"); + // make a view - au_view = [factoryInstance uiViewForAudioUnit:*au->get_au() withSize:crect.size]; - + au_view = [factory uiViewForAudioUnit:*au->get_au() withSize:NSZeroSize]; + + DEBUG_TRACE (DEBUG::AudioUnits, string_compose ("view created @ %1\n", au_view)); + // cleanup [CocoaViewBundlePath release]; if (cocoaViewInfo) { UInt32 i; for (i = 0; i < numberOfClasses; i++) CFRelease(cocoaViewInfo->mCocoaAUViewClass[i]); - + free (cocoaViewInfo); } - wasAbleToLoadCustomView = YES; + wasAbleToLoadCustomView = true; } } if (!wasAbleToLoadCustomView) { - // [B] Otherwise show generic Cocoa view + // load generic Cocoa view + DEBUG_TRACE (DEBUG::AudioUnits, string_compose ("Loading generic view using %1 -> %2\n", au, + au->get_au())); au_view = [[AUGenericView alloc] initWithAudioUnit:*au->get_au()]; - [(AUGenericView *)au_view setShowsExpertParameters:YES]; + DEBUG_TRACE (DEBUG::AudioUnits, string_compose ("view created @ %1\n", au_view)); + [(AUGenericView *)au_view setShowsExpertParameters:1]; } - /* make a child cocoa window */ + // Get the initial size of the new AU View's frame + NSRect frame = [au_view frame]; + req_width = frame.size.width; + req_height = frame.size.height; - cocoa_window = [[NSWindow alloc] - initWithContentRect:crect - styleMask:NSBorderlessWindowMask - backing:NSBackingStoreBuffered - defer:NO]; + resizable = [au_view autoresizingMask]; + + low_box.queue_resize (); return 0; } +void +AUPluginUI::update_view_size () +{ + last_au_frame = [au_view frame]; +} + +bool +AUPluginUI::timer_callback () +{ + block_plugin_redraws = 0; +#ifdef AU_DEBUG_PRINT + std::cerr << "Resume redraws after idle\n"; +#endif + return false; +} + +void +au_cf_timer_callback (CFRunLoopTimerRef timer, void* info) +{ + reinterpret_cast (info)->cf_timer_callback (); +} + +void +AUPluginUI::cf_timer_callback () +{ + int64_t now = ARDOUR::get_microseconds (); + + if (!last_timer || block_plugin_redraws) { + last_timer = now; + return; + } + + const int64_t usecs_slop = (1400000 / minimum_redraw_rate); // 140% + +#ifdef AU_DEBUG_PRINT + std::cerr << "Timer elapsed : " << now - last_timer << std::endl; +#endif + + if ((now - last_timer) > (usecs_slop + (1000000/minimum_redraw_rate))) { + block_plugin_redraws = block_plugin_redraw_count; + timer_connection.disconnect (); + timer_connection = Glib::signal_timeout().connect (&AUPluginUI::timer_callback, 40); +#ifdef AU_DEBUG_PRINT + std::cerr << "Timer too slow, block plugin redraws\n"; +#endif + } + + last_timer = now; +} + +void +AUPluginUI::start_cf_timer () +{ + if (!timer_needed) { + return; + } + + CFTimeInterval interval = 1.0 / (float) minimum_redraw_rate; + + cf_timer = CFRunLoopTimerCreate (kCFAllocatorDefault, + CFAbsoluteTimeGetCurrent() + interval, + interval, 0, 0, + au_cf_timer_callback, + 0); + + CFRunLoopAddTimer (CFRunLoopGetCurrent(), cf_timer, kCFRunLoopCommonModes); + timer_needed = false; +} + +void +AUPluginUI::stop_cf_timer () +{ + if (timer_needed) { + return; + } + + CFRunLoopRemoveTimer (CFRunLoopGetCurrent(), cf_timer, kCFRunLoopCommonModes); + timer_needed = true; + last_timer = 0; +} + +void +AUPluginUI::cocoa_view_resized () +{ + /* we can get here for two reasons: + + 1) the plugin window was resized by the user, a new size was + allocated to the window, ::update_view_size() was called, and we + explicitly/manually resized the AU NSView. + + 2) the plugin decided to resize itself (probably in response to user + action, but not in response to an actual window resize) + + We only want to proceed with a window resizing in the second case. + */ + + if (in_live_resize) { + /* ::update_view_size() will be called at the right times and + * will update the view size. We don't need to anything while a + * live resize in underway. + */ + return; + } + + if (plugin_requested_resize) { + /* we tried to change the plugin frame from inside this method + * (to adjust the origin), which changes the frame of the AU + * NSView, resulting in a reentrant call to the FrameDidChange + * handler (this method). Ignore this reentrant call. + */ +#ifdef AU_DEBUG_PRINT + std::cerr << plugin->name() << " re-entrant call to cocoa_view_resized, ignored\n"; +#endif + return; + } + + plugin_requested_resize = 1; + + ProcessorWindowProxy* wp = insert->window_proxy(); + if (wp) { + /* Once a plugin has requested a resize of its own window, do + * NOT save the window. The user may save state with the plugin + * editor expanded to show "extra detail" - the plugin will not + * refill this space when the editor is first + * instantiated. Leaving the window in the "too big" state + * cannot be recovered from. + * + * The window will be sized to fit the plugin's own request. Done. + */ + wp->set_state_mask (WindowProxy::Position); + } + + NSRect new_frame = [au_view frame]; + + /* from here on, we know that we've been called because the plugin + * decided to change the NSView frame itself. + */ + + /* step one: compute the change in the frame size. + */ + + float dy = new_frame.size.height - last_au_frame.size.height; + float dx = new_frame.size.width - last_au_frame.size.width; + + NSWindow* window = get_nswindow (); + NSRect windowFrame= [window frame]; + + /* we want the top edge of the window to remain in the same place, + but the Cocoa/Quartz origin is at the lower left. So, when we make + the window larger, we will move it down, which means shifting the + origin toward (x,0). This will leave the top edge in the same place. + */ + + windowFrame.origin.y -= dy; + windowFrame.origin.x -= dx; + windowFrame.size.height += dy; + windowFrame.size.width += dx; + + NSUInteger old_auto_resize = [au_view autoresizingMask]; + + /* Some stupid AU Views change the origin of the original AU View when + they are resized (I'm looking at you AUSampler). If the origin has + been moved, move it back. + */ + + if (last_au_frame.origin.x != new_frame.origin.x || + last_au_frame.origin.y != new_frame.origin.y) { + new_frame.origin = last_au_frame.origin; + [au_view setFrame:new_frame]; + /* also be sure to redraw the topbox because this can + also go wrong. + */ + top_box.queue_draw (); + } + + /* We resize the window using Cocoa. We can't use GTK mechanisms + * because of this: + * + * http://www.lists.apple.com/archives/coreaudio-api/2005/Aug/msg00245.html + * + * "The host needs to be aware that changing the size of the window in + * response to the NSViewFrameDidChangeNotification can cause the view + * size to change depending on the autoresizing mask of the view. The + * host may need to cache the autoresizing mask of the view, set it to + * NSViewNotSizable, resize the window, and then reset the autoresizing + * mask of the view once the window has been sized." + * + */ + + [au_view setAutoresizingMask:NSViewNotSizable]; + [window setFrame:windowFrame display:1]; + [au_view setAutoresizingMask:old_auto_resize]; + + /* keep a copy of the size of the AU NSView. We didn't set it - the plugin did */ + last_au_frame = new_frame; + req_width = new_frame.size.width; + req_height = new_frame.size.height; + + plugin_requested_resize = 0; +} + int -AUPluginUI::create_carbon_view (bool generic) +AUPluginUI::create_carbon_view () { +#ifdef WITH_CARBON OSStatus err; ControlRef root_control; Component editComponent = FindNextComponent(NULL, &carbon_descriptor); - + OpenAComponent(editComponent, &editView); if (!editView) { error << _("AU Carbon view: cannot open AU Component") << endmsg; return -1; } - + Rect r = { 100, 100, 100, 100 }; WindowAttributes attr = WindowAttributes (kWindowStandardHandlerAttribute | kWindowCompositingAttribute| kWindowNoShadowAttribute| kWindowNoTitleBarAttribute); - if ((err = CreateNewWindow(kDocumentWindowClass, attr, &r, &carbon_window)) != noErr) { + if ((err = CreateNewWindow(kUtilityWindowClass, attr, &r, &carbon_window)) != noErr) { error << string_compose (_("AUPluginUI: cannot create carbon window (err: %1)"), err) << endmsg; + ArdourCloseComponent (editView); return -1; } - + if ((err = GetRootControl(carbon_window, &root_control)) != noErr) { error << string_compose (_("AUPlugin: cannot get root control of carbon window (err: %1)"), err) << endmsg; + DisposeWindow (carbon_window); + ArdourCloseComponent (editView); return -1; } @@ -266,6 +946,8 @@ AUPluginUI::create_carbon_view (bool generic) if ((err = AudioUnitCarbonViewCreate (editView, *au->get_au(), carbon_window, root_control, &location, &size, &viewPane)) != noErr) { error << string_compose (_("AUPluginUI: cannot create carbon plugin view (err: %1)"), err) << endmsg; + DisposeWindow (carbon_window); + ArdourCloseComponent (editView); return -1; } @@ -275,15 +957,18 @@ AUPluginUI::create_carbon_view (bool generic) GetControlBounds(viewPane, &bounds); size.x = bounds.right-bounds.left; size.y = bounds.bottom-bounds.top; - SizeWindow(carbon_window, (short) (size.x + 0.5), (short) (size.y + 0.5), true); - prefwidth = (int) (size.x + 0.5); - prefheight = (int) (size.y + 0.5); + req_width = (int) (size.x + 0.5); + req_height = (int) (size.y + 0.5); + + SizeWindow (carbon_window, req_width, req_height, true); + low_box.set_size_request (req_width, req_height); -#if 0 - mViewPaneResizer->WantEventTypes (GetControlEventTarget(mAUViewPane), GetEventTypeCount(resizeEvent), resizeEvent); -#endif return 0; +#else + error << _("AU Carbon GUI is not supported.") << endmsg; + return -1; +#endif } NSWindow* @@ -309,73 +994,35 @@ AUPluginUI::get_nswindow () void AUPluginUI::activate () { - NSWindow* win = get_nswindow (); - [win setLevel:NSFloatingWindowLevel]; - - if (carbon_parented) { - [cocoa_parent makeKeyAndOrderFront:nil]; - ActivateWindow (carbon_window, TRUE); - } +#ifdef WITH_CARBON + ActivateWindow (carbon_window, TRUE); +#endif } void AUPluginUI::deactivate () { - /* nothing to do here */ -} - - -OSStatus -_carbon_event (EventHandlerCallRef nextHandlerRef, EventRef event, void *userData) -{ - return ((AUPluginUI*)userData)->carbon_event (nextHandlerRef, event); -} - -OSStatus -AUPluginUI::carbon_event (EventHandlerCallRef nextHandlerRef, EventRef event) -{ - UInt32 eventKind = GetEventKind(event); - ClickActivationResult howToHandleClick; - NSWindow* win = get_nswindow (); - - switch (eventKind) { - case kEventWindowHandleActivate: - [win makeMainWindow]; - return eventNotHandledErr; - break; - - case kEventWindowHandleDeactivate: - return eventNotHandledErr; - break; - - case kEventWindowGetClickActivation: - howToHandleClick = kActivateAndHandleClick; - SetEventParameter(event, kEventParamClickActivation, typeClickActivationResult, - sizeof(ClickActivationResult), &howToHandleClick); - break; - } - - return noErr; +#ifdef WITH_CARBON + ActivateWindow (carbon_window, FALSE); +#endif } int AUPluginUI::parent_carbon_window () { +#ifdef WITH_CARBON NSWindow* win = get_nswindow (); - int x, y; + Rect windowStructureBoundsRect; if (!win) { return -1; } - Gtk::Container* toplevel = get_toplevel(); + /* figure out where the cocoa parent window is in carbon-coordinate space, which + differs from both cocoa-coordinate space and GTK-coordinate space + */ - if (!toplevel || !toplevel->is_toplevel()) { - error << _("AUPluginUI: no top level window!") << endmsg; - return -1; - } - - toplevel->get_window()->get_root_origin (x, y); + GetWindowBounds((WindowRef) [win windowRef], kWindowStructureRgn, &windowStructureBoundsRect); /* compute how tall the title bar is, because we have to offset the position of the carbon window by that much. @@ -386,34 +1033,30 @@ AUPluginUI::parent_carbon_window () int titlebar_height = wm_frame.size.height - content_frame.size.height; - MoveWindow (carbon_window, x, y + titlebar_height, false); + int packing_extra = 6; // this is the total vertical packing in our top level window + + /* move into position, based on parent window position */ + MoveWindow (carbon_window, + windowStructureBoundsRect.left, + windowStructureBoundsRect.top + titlebar_height + top_box.get_height() + packing_extra, + false); ShowWindow (carbon_window); // create the cocoa window for the carbon one and make it visible cocoa_parent = [[NSWindow alloc] initWithWindowRef: carbon_window]; - EventTypeSpec windowEventTypes[] = { - {kEventClassWindow, kEventWindowGetClickActivation }, - {kEventClassWindow, kEventWindowHandleDeactivate }, - {kEventClassWindow, kEventWindowHandleActivate } - }; - - EventHandlerUPP ehUPP = NewEventHandlerUPP(_carbon_event); - OSStatus result = InstallWindowEventHandler (carbon_window, ehUPP, - sizeof(windowEventTypes) / sizeof(EventTypeSpec), - windowEventTypes, this, &carbon_event_handler); - if (result != noErr) { - return -1; - } + SetWindowActivationScope (carbon_window, kWindowActivationScopeNone); + + _notify = [ [NotificationObject alloc] initWithPluginUI:this andCocoaParent:cocoa_parent andTopLevelParent:win ]; [win addChildWindow:cocoa_parent ordered:NSWindowAbove]; - [win setLevel:NSFloatingWindowLevel]; - [win setHidesOnDeactivate:YES]; + [win setAutodisplay:1]; // turn of GTK stuff for this window - carbon_parented = true; - return 0; -} +#else + return -1; +#endif +} int AUPluginUI::parent_cocoa_window () @@ -424,136 +1067,212 @@ AUPluginUI::parent_cocoa_window () return -1; } + //[win setAutodisplay:1]; // turn off GTK stuff for this window + + NSView* view = gdk_quartz_window_get_nsview (low_box.get_window()->gobj()); + [view addSubview:au_view]; + /* despite the fact that the documentation says that [NSWindow + contentView] is the highest "accessible" NSView in an NSWindow, when + the redraw cycle is executed, displayIfNeeded is actually executed + on the parent of the contentView. To provide a marginal speedup when + checking if a given redraw is for a plugin, use this "hidden" NSView + to identify the plugin, so that we do not have to call [superview] + every time in interposed_drawIfNeeded(). + */ + add_plugin_view ([[win contentView] superview]); + + /* this moves the AU NSView down and over to provide a left-hand margin + * and to clear the Ardour "task bar" (with plugin preset mgmt buttons, + * keyboard focus control, bypass etc). + */ + + gint xx, yy; + gtk_widget_translate_coordinates( + GTK_WIDGET(low_box.gobj()), + GTK_WIDGET(low_box.get_parent()->gobj()), + 8, 6, &xx, &yy); + [au_view setFrame:NSMakeRect(xx, yy, req_width, req_height)]; + + last_au_frame = [au_view frame]; + // watch for size changes of the view + _notify = [ [NotificationObject alloc] initWithPluginUI:this andCocoaParent:NULL andTopLevelParent:win ]; + + [[NSNotificationCenter defaultCenter] addObserver:_notify + selector:@selector(auViewResized:) name:NSViewFrameDidChangeNotification + object:au_view]; + + // catch notifications that live resizing is about to start + +#if HAVE_COCOA_LIVE_RESIZING + _resize_notify = [ [ LiveResizeNotificationObject alloc] initWithPluginUI:this ]; + + [[NSNotificationCenter defaultCenter] addObserver:_resize_notify + selector:@selector(windowWillStartLiveResizeHandler:) name:NSWindowWillStartLiveResizeNotification + object:win]; + + [[NSNotificationCenter defaultCenter] addObserver:_resize_notify + selector:@selector(windowWillEndLiveResizeHandler:) name:NSWindowDidEndLiveResizeNotification + object:win]; +#else + /* No way before 10.6 to identify the start of a live resize (drag + * resize) without subclassing NSView and overriding two of its + * methods. Instead of that, we make the window non-resizable, thus + * ending confusion about whether or not resizes are plugin or user + * driven (they are always plugin-driven). + */ + Gtk::Container* toplevel = get_toplevel(); + Requisition req; - if (!toplevel || !toplevel->is_toplevel()) { - error << _("AUPluginUI: no top level window!") << endmsg; - return -1; + resizable = false; + + if (toplevel && toplevel->is_toplevel()) { + toplevel->size_request (req); + toplevel->set_size_request (req.width, req.height); + dynamic_cast(toplevel)->set_resizable (false); } - - // Get the size of the new AU View's frame - NSRect au_view_frame = [au_view frame]; - - if (au_view_frame.size.width > 500 || au_view_frame.size.height > 500) { - - /* its too big - use a scrollview */ - - NSRect frameRect = [[cocoa_window contentView] frame]; - scroll_view = [[[NSScrollView alloc] initWithFrame:frameRect] autorelease]; - [scroll_view setDrawsBackground:NO]; - [scroll_view setHasHorizontalScroller:YES]; - [scroll_view setHasVerticalScroller:YES]; - - NSSize frameSize = [NSScrollView frameSizeForContentSize:au_view_frame.size - hasHorizontalScroller:[scroll_view hasHorizontalScroller] - hasVerticalScroller:[scroll_view hasVerticalScroller] - borderType:[scroll_view borderType]]; - - // Create a new frame with same origin as current - // frame but size equal to the size of the new view - NSRect newFrame; - newFrame.origin = [scroll_view frame].origin; - newFrame.size = frameSize; - - // Set the new frame and document views on the scroll view - NSRect currentFrame = [scroll_view frame]; - [scroll_view setFrame:newFrame]; - [scroll_view setDocumentView:au_view]; - - cerr << "scroll view size is " << newFrame.size.width << " x " << newFrame.size.height << endl; - - NSSize oldContentSize = [[cocoa_window contentView] frame].size; - NSSize newContentSize = oldContentSize; - - cerr << "original size is " << newContentSize.width << " x " << newContentSize.height << endl; - - newContentSize.width += (newFrame.size.width - currentFrame.size.width); - newContentSize.height += (newFrame.size.height - currentFrame.size.height); - - [cocoa_window setContentSize:newContentSize]; - [cocoa_window setContentView:scroll_view]; - - } else { - [cocoa_window setContentSize:au_view_frame.size]; - [cocoa_window setContentView:au_view]; +#endif + return 0; +} +void +AUPluginUI::grab_focus() +{ + if (au_view) { + [au_view becomeFirstResponder]; } +} +void +AUPluginUI::forward_key_event (GdkEventKey* ev) +{ + NSEvent* nsevent = gdk_quartz_event_get_nsevent ((GdkEvent*)ev); - /* compute how tall the title bar is, because we have to offset the position of the child window - by that much. - */ - - NSRect content_frame = [NSWindow contentRectForFrameRect:[win frame] styleMask:[win styleMask]]; - NSRect wm_frame = [NSWindow frameRectForContentRect:content_frame styleMask:[win styleMask]]; - int titlebar_height = wm_frame.size.height - content_frame.size.height; + if (au_view && nsevent) { - // move cocoa window into position relative to the toplevel window + /* filter on nsevent type here because GDK massages FlagsChanged + messages into GDK_KEY_{PRESS,RELEASE} but Cocoa won't + handle a FlagsChanged message as a keyDown or keyUp + */ - NSRect view_frame = [[cocoa_window contentView] frame]; - view_frame.origin.x = content_frame.origin.x; - view_frame.origin.y = content_frame.origin.y; + if ([nsevent type] == NSKeyDown) { + [[[au_view window] firstResponder] keyDown:nsevent]; + } else if ([nsevent type] == NSKeyUp) { + [[[au_view window] firstResponder] keyUp:nsevent]; + } else if ([nsevent type] == NSFlagsChanged) { + [[[au_view window] firstResponder] flagsChanged:nsevent]; + } + } +} - [cocoa_window setFrame:view_frame display:NO]; +void +AUPluginUI::on_realize () +{ + VBox::on_realize (); - /* make top level window big enough to hold cocoa window and titlebar */ - - content_frame.size.width = view_frame.size.width; - content_frame.size.height = view_frame.size.height + titlebar_height; + /* our windows should not have that resize indicator */ - [win setFrame:content_frame display:NO]; + NSWindow* win = get_nswindow (); + if (win) { + [win setShowsResizeIndicator:0]; + } +} - /* now make cocoa window a child of this top level */ +void +AUPluginUI::lower_box_realized () +{ + if (au_view) { + parent_cocoa_window (); + } else if (carbon_window) { + parent_carbon_window (); + } +} - [win addChildWindow:cocoa_window ordered:NSWindowAbove]; - // [win setLevel:NSFloatingWindowLevel]; - [win setHidesOnDeactivate:YES]; +bool +AUPluginUI::lower_box_visibility_notify (GdkEventVisibility* ev) +{ +#ifdef WITH_CARBON + if (carbon_window && ev->state != GDK_VISIBILITY_UNOBSCURED) { + ShowWindow (carbon_window); + ActivateWindow (carbon_window, TRUE); + return true; + } +#endif + return false; +} - cocoa_parented = true; +void +AUPluginUI::lower_box_map () +{ + [au_view setHidden:0]; + update_view_size (); +} - return 0; +void +AUPluginUI::lower_box_unmap () +{ + [au_view setHidden:1]; } void -AUPluginUI::on_realize () +AUPluginUI::lower_box_size_request (GtkRequisition* requisition) { - VBox::on_realize (); + requisition->width = req_width; + requisition->height = req_height; +} - if (cocoa_window) { - - if (parent_cocoa_window ()) { - } +void +AUPluginUI::lower_box_size_allocate (Gtk::Allocation& allocation) +{ + update_view_size (); +} - } else if (carbon_window) { +void +AUPluginUI::on_window_hide () +{ +#ifdef WITH_CARBON + if (carbon_window) { + HideWindow (carbon_window); + ActivateWindow (carbon_window, FALSE); + } +#endif + hide_all (); - if (parent_carbon_window ()) { - // ShowWindow (carbon_window); - } +#if 0 + NSArray* wins = [NSApp windows]; + for (uint32_t i = 0; i < [wins count]; i++) { + id win = [wins objectAtIndex:i]; } +#endif } -void -AUPluginUI::on_show () +bool +AUPluginUI::on_window_show (const string& /*title*/) { - cerr << "AU plugin window shown\n"; + /* this is idempotent so just call it every time we show the window */ - VBox::on_show (); + gtk_widget_realize (GTK_WIDGET(low_box.gobj())); - if (cocoa_window) { - [cocoa_window setIsVisible:YES]; - } else if (carbon_window) { - [cocoa_parent setIsVisible:YES]; + show_all (); + +#ifdef WITH_CARBON + if (carbon_window) { + ShowWindow (carbon_window); + ActivateWindow (carbon_window, TRUE); } +#endif + + return true; } bool -AUPluginUI::start_updating (GdkEventAny* any) +AUPluginUI::start_updating (GdkEventAny*) { return false; } bool -AUPluginUI::stop_updating (GdkEventAny* any) +AUPluginUI::stop_updating (GdkEventAny*) { return false; } @@ -565,3 +1284,15 @@ create_au_gui (boost::shared_ptr plugin_insert, VBox** box) (*box) = aup; return aup; } + +void +AUPluginUI::start_live_resize () +{ + in_live_resize = true; +} + +void +AUPluginUI::end_live_resize () +{ + in_live_resize = false; +}