FlutterMenuPlugin Class Reference

#include <FlutterMenuPlugin.h>

Inheritance diagram for FlutterMenuPlugin:

Instance Methods
(instancetype)	- initWithChannel: [implementation]
(void)	- replaceAppName: [implementation]
(NSMenuItem *)	- findProvidedMenuItem:ofType: [implementation]
(NSMenuItem *)	- createPlatformProvidedMenu: [implementation]
(NSMenuItem *)	- menuItemFromFlutterRepresentation: [implementation]
(void)	- flutterMenuItemSelected: [implementation]
(void)	- handleMethodCall:result: [implementation]
(void)	- setMenus: [implementation]
Instance Methods inherited from <FlutterPlugin>
(void)	- detachFromEngineForRegistrar:
Instance Methods inherited from <FlutterApplicationLifeCycleDelegate>
(BOOL)	- application:didFinishLaunchingWithOptions:
(BOOL)	- application:willFinishLaunchingWithOptions:
(void)	- applicationDidBecomeActive:
(void)	- applicationWillResignActive:
(void)	- applicationDidEnterBackground:
(void)	- applicationWillEnterForeground:
(void)	- applicationWillTerminate:
(void)	- application:didRegisterUserNotificationSettings:
(void)	- application:didRegisterForRemoteNotificationsWithDeviceToken:
(void)	- application:didFailToRegisterForRemoteNotificationsWithError:
(BOOL)	- application:didReceiveRemoteNotification:fetchCompletionHandler:
(void)	- application:didReceiveLocalNotification:
(BOOL)	- application:openURL:options:
(BOOL)	- application:handleOpenURL:
(BOOL)	- application:openURL:sourceApplication:annotation:
(BOOL)	- application:performActionForShortcutItem:completionHandler:
(BOOL)	- application:handleEventsForBackgroundURLSession:completionHandler:
(BOOL)	- application:performFetchWithCompletionHandler:
(BOOL)	- application:continueUserActivity:restorationHandler:
Instance Methods inherited from <FlutterAppLifecycleDelegate>
(void)	- handleWillFinishLaunching:
(void)	- handleDidFinishLaunching:
(void)	- handleWillBecomeActive:
(void)	- handleDidBecomeActive:
(void)	- handleWillResignActive:
(void)	- handleDidResignActive:
(void)	- handleWillHide:
(void)	- handleDidHide:
(void)	- handleWillUnhide:
(void)	- handleDidUnhide:
(void)	- handleDidChangeScreenParameters:
(void)	- handleDidChangeOcclusionState:
(BOOL)	- handleOpenURLs:
(void)	- handleWillTerminate:

Class Methods
(void)	+ registerWithRegistrar:
Class Methods inherited from <FlutterPlugin>
(void)	+ registerWithRegistrar:
(void)	+ setPluginRegistrantCallback:
(void)	+ registerWithRegistrar:

Detailed Description

A plugin to configure and control the native system menu.

Responsible for bridging the native macOS menu system with the Flutter framework's PlatformMenuBar class, via method channels.

Definition at line 20 of file FlutterMenuPlugin.h.

Method Documentation

createPlatformProvidedMenu:

- (NSMenuItem *) createPlatformProvidedMenu: (flutter::PlatformProvidedMenu)  type

implementation

Definition at line 229 of file FlutterMenuPlugin.mm.

                                         :(flutter::PlatformProvidedMenu)type {
  const std::map<flutter::PlatformProvidedMenu, SEL> providedMenus = GetMacOSProvidedMenus();
  auto found_type = providedMenus.find(type);
  if (found_type == providedMenus.end()) {
    return nil;
  }
  SEL selectorTarget = found_type->second;
  // Since it doesn't have a definitive selector, the Services submenu is
  // assumed to be the first item with a submenu action in the first menu item
  // of the default menu set. We can't just get the title to check, since that
  // is localized, and the contents of the menu aren't fixed (or even available).
  NSMenu* startingMenu = type == flutter::PlatformProvidedMenu::kServicesSubmenu
                             ? [_platformProvidedItems[0] submenu]
                             : nil;
  NSMenuItem* found = [self findProvidedMenuItem:startingMenu ofType:selectorTarget];
  // Return a copy because the original menu item might not have been removed
  // from the main menu yet, and AppKit doesn't like menu items that exist in
  // more than one menu at a time.
  return [found copy];
}

findProvidedMenuItem:ofType:

- (NSMenuItem *) findProvidedMenuItem: (NSMenu*)  menu ofType: (SEL)  selector

implementation

Definition at line 229 of file FlutterMenuPlugin.mm.

                                   :(NSMenu*)menu ofType:(SEL)selector {
  const NSArray<NSMenuItem*>* items = menu ? menu.itemArray : _platformProvidedItems;
  for (NSMenuItem* item in items) {
    if ([item action] == selector) {
      return item;
    }
    if ([[item submenu] numberOfItems] > 0) {
      NSMenuItem* foundChild = [self findProvidedMenuItem:[item submenu] ofType:selector];
      if (foundChild) {
        return foundChild;
      }
    }
  }
  return nil;
}

flutterMenuItemSelected:

- (void) flutterMenuItemSelected: (id)  sender

implementation

Definition at line 229 of file FlutterMenuPlugin.mm.

                               :(id)sender {
  NSMenuItem* item = sender;
  [_channel invokeMethod:kMenuSelectedCallbackMethod arguments:@(item.tag)];
}

handleMethodCall:result:

- (void) handleMethodCall: (FlutterMethodCall *)  call result: (FlutterResult)  result

implementation

Called if this plugin has been registered to receive FlutterMethodCalls.

Parameters

call	The method call command object.
result	A callback for submitting the result of the call.

Reimplemented from <FlutterPlugin>.

Definition at line 229 of file FlutterMenuPlugin.mm.

                        :(FlutterMethodCall*)call result:(FlutterResult)result {
  if ([call.method isEqualToString:kIsPluginAvailableMethod]) {
    result(@YES);
  } else if ([call.method isEqualToString:kMenuSetMenusMethod]) {
    NSDictionary* menus = call.arguments;
    [self setMenus:menus];
    result(nil);
  } else {
    result(FlutterMethodNotImplemented);
  }
}

initWithChannel:

- (instancetype) initWithChannel: (FlutterMethodChannel*)  channel

implementation

Definition at line 229 of file FlutterMenuPlugin.mm.

                               :(FlutterMethodChannel*)channel {
  self = [super init];
  if (self) {
    _channel = channel;
    _platformProvidedItems = @[];
    _menuDelegates = [[NSMutableArray alloc] init];
 
    // Make a copy of all the platform provided menus for later use.
    _platformProvidedItems = [[NSApp.mainMenu itemArray] mutableCopy];
 
    // As copied, these platform provided menu items don't yet have the APP_NAME
    // string replaced in them, so this rectifies that.
    [self replaceAppName:_platformProvidedItems];
  }
  return self;
}

menuItemFromFlutterRepresentation:

- (NSMenuItem *) menuItemFromFlutterRepresentation: (NSDictionary*)  representation

implementation

Definition at line 229 of file FlutterMenuPlugin.mm.

                                                :(NSDictionary*)representation {
  if ([(NSNumber*)([representation valueForKey:kDividerKey]) intValue] == YES) {
    return [NSMenuItem separatorItem];
  }
  NSNumber* platformProvidedMenuId = representation[kPlatformProvidedMenuKey];
  NSString* keyEquivalent = @"";
 
  if (platformProvidedMenuId) {
    return [self
        createPlatformProvidedMenu:(flutter::PlatformProvidedMenu)platformProvidedMenuId.intValue];
  } else {
    if (representation[kShortcutCharacterKey]) {
      keyEquivalent = representation[kShortcutCharacterKey];
    } else {
      NSNumber* triggerKeyId = representation[kShortcutTriggerKey];
      const NSDictionary<NSNumber*, NSNumber*>* specialKeys = GetMacOsSpecialKeys();
      NSNumber* trigger = specialKeys[triggerKeyId];
      if (trigger) {
        keyEquivalent = [NSString stringWithFormat:@"%C", [trigger unsignedShortValue]];
      } else {
        if (([triggerKeyId unsignedLongLongValue] & kFlutterKeyIdPlaneMask) ==
            kFlutterKeyIdUnicodePlane) {
          keyEquivalent = [[NSString
              stringWithFormat:@"%C", (unichar)([triggerKeyId unsignedLongLongValue] &
                                                kFlutterKeyIdValueMask)] lowercaseString];
        }
      }
    }
  }
 
  NSNumber* identifier = representation[kIdKey];
  SEL action = (identifier ? @selector(flutterMenuItemSelected:) : NULL);
  NSString* appName = [NSRunningApplication currentApplication].localizedName;
  NSString* title = [representation[kLabelKey] stringByReplacingOccurrencesOfString:kAppName
                                                                         withString:appName];
  NSMenuItem* item = [[NSMenuItem alloc] initWithTitle:title
                                                action:action
                                         keyEquivalent:keyEquivalent];
  if ([keyEquivalent length] > 0) {
    item.keyEquivalentModifierMask =
        KeyEquivalentModifierMaskForModifiers(representation[kShortcutModifiersKey]);
  }
  if (identifier) {
    item.tag = identifier.longLongValue;
    item.target = self;
  }
  NSNumber* enabled = representation[kEnabledKey];
  if (enabled) {
    item.enabled = enabled.boolValue;
  }
 
  NSArray* children = representation[kChildrenKey];
  if (children && children.count > 0) {
    NSMenu* submenu = [[NSMenu alloc] initWithTitle:title];
    FlutterMenuDelegate* delegate = [[FlutterMenuDelegate alloc] initWithIdentifier:item.tag
                                                                            channel:_channel];
    [_menuDelegates addObject:delegate];
    submenu.delegate = delegate;
    submenu.autoenablesItems = NO;
    for (NSDictionary* child in children) {
      NSMenuItem* newItem = [self menuItemFromFlutterRepresentation:child];
      if (newItem) {
        [submenu addItem:newItem];
      }
    }
    item.submenu = submenu;
  }
  return item;
}

registerWithRegistrar:

+ (void) registerWithRegistrar:

(nonnull id<FlutterPluginRegistrar>)

registrar

Registers a FlutterMenuPlugin with the given registrar.

Definition at line 229 of file FlutterMenuPlugin.mm.

                             :(nonnull id<FlutterPluginRegistrar>)registrar {
  FlutterMethodChannel* channel = [FlutterMethodChannel methodChannelWithName:kChannelName
                                                              binaryMessenger:registrar.messenger];
  FlutterMenuPlugin* instance = [[FlutterMenuPlugin alloc] initWithChannel:channel];
  [registrar addMethodCallDelegate:instance channel:channel];
}

replaceAppName:

- (void) replaceAppName: (NSArray<NSMenuItem*>*)  items

implementation

Iterates through the given menu hierarchy, and replaces "APP_NAME" with the localized running application name.

Definition at line 229 of file FlutterMenuPlugin.mm.

                      :(NSArray<NSMenuItem*>*)items {
  NSString* appName = [NSRunningApplication currentApplication].localizedName;
  for (NSMenuItem* item in items) {
    if ([[item title] containsString:kAppName]) {
      [item setTitle:[[item title] stringByReplacingOccurrencesOfString:kAppName
                                                             withString:appName]];
    }
    if ([item hasSubmenu]) {
      [self replaceAppName:[[item submenu] itemArray]];
    }
  }
}

setMenus:

- (void) setMenus: (NSDictionary*)  representation

implementation

Definition at line 229 of file FlutterMenuPlugin.mm.

                :(NSDictionary*)representation {
  [_menuDelegates removeAllObjects];
  NSMenu* newMenu = [[NSMenu alloc] init];
  // There's currently only one window, named "0", but there could be other
  // eventually, with different menu configurations.
  for (NSDictionary* item in representation[@"0"]) {
    NSMenuItem* menuItem = [self menuItemFromFlutterRepresentation:item];
    menuItem.representedObject = self;
    NSNumber* identifier = item[kIdKey];
    FlutterMenuDelegate* delegate =
        [[FlutterMenuDelegate alloc] initWithIdentifier:identifier.longLongValue channel:_channel];
    [_menuDelegates addObject:delegate];
    [menuItem submenu].delegate = delegate;
    [newMenu addItem:menuItem];
  }
  NSApp.mainMenu = newMenu;
}

---

The documentation for this class was generated from the following files:

• shell/platform/darwin/macos/framework/Source/FlutterMenuPlugin.h
• shell/platform/darwin/macos/framework/Source/FlutterMenuPlugin.mm