/*****************************************************************************
 *MainMenu.m: MacOS X interface module
 *****************************************************************************
 *Copyright (C) 2011-2026 Felix Paul Kühne
 *
 *Authors: Felix Paul Kühne <fkuehne -at- videolan -dot- org>
 *
 *This program is free software; you can redistribute it and/or modify
 *it under the terms of the GNU General Public License as published by
 *the Free Software Foundation; either version 2 of the License, or
 *(at your option) any later version.
 *
 *This program is distributed in the hope that it will be useful,
 *but WITHOUT ANY WARRANTY; without even the implied warranty of
 *MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *GNU General Public License for more details.
 *
 *You should have received a copy of the GNU General Public License
 *along with this program; if not, write to the Free Software
 *Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
 *****************************************************************************/

#import "VLCMainMenu.h"

#import "extensions/NSMenuItem+VLCAdditions.h"
#import "extensions/NSScreen+VLCAdditions.h"
#import "extensions/NSString+Helpers.h"

#import "library/VLCLibraryController.h"
#import "library/VLCLibraryWindow.h"
#import "library/VLCLibraryWindowController.h"
#import "library/VLCLibraryWindowSplitViewController.h"

#import "main/VLCMain.h"

#import "menus/VLCRecentStreamsMenuController.h"
#import "menus/renderers/VLCRendererMenuController.h"

#import "panels/VLCAudioEffectsWindowController.h"
#import "panels/VLCTrackSynchronizationWindowController.h"
#import "panels/VLCVideoEffectsWindowController.h"
#import "panels/VLCBookmarksWindowController.h"
#import "panels/dialogs/VLCCoreDialogProvider.h"
#import "panels/dialogs/VLCCustomCropArWindowController.h"
#import "panels/VLCInformationWindowController.h"
#import "panels/VLCTimeSelectionPanelController.h"

#import "playqueue/VLCPlayQueueController.h"
#import "playqueue/VLCPlayQueueModel.h"
#import "playqueue/VLCPlayerController.h"
#import "playqueue/VLCPlayQueueSortingMenuController.h"
#import "preferences/VLCSimplePrefsController.h"

#import "windows/VLCAboutWindowController.h"
#import "windows/VLCConnectToServerDialog.h"
#import "windows/VLCDetachedAudioWindow.h"
#import "windows/VLCOpenWindowController.h"
#import "windows/VLCErrorWindowController.h"
#import "windows/VLCHelpWindowController.h"
#import "windows/controlsbar/VLCMainWindowControlsBar.h"
#import "windows/extensions/VLCExtensionsManager.h"
#import "windows/convertandsave/VLCConvertAndSaveWindowController.h"
#import "windows/logging/VLCLogWindowController.h"
#import "windows/addons/VLCAddonsWindowController.h"
#import "windows/video/VLCVoutView.h"
#import "windows/video/VLCVideoOutputProvider.h"

#import <vlc_configuration.h>
#import <vlc_interface.h>

#ifdef HAVE_SPARKLE
#import <Sparkle/Sparkle.h>
#endif

typedef NS_ENUM(NSInteger, VLCObjectType) {
    VLCObjectTypeInterface,
    VLCObjectTypeAout,
    VLCObjectTypeVout,
};

@interface VLCAutoGeneratedMenuContent : NSObject
{
    vlc_object_t *_vlcObject;
}
- (instancetype)initWithVariableName:(const char *)name
                            ofObject:(vlc_object_t *)object
                      withObjectType:(VLCObjectType)objectType
                            andValue:(vlc_value_t)value
                      ofVariableType:(int)type;

@property (readonly) char *variableName;
@property (readonly) vlc_value_t variableValue;
@property (readonly) vlc_object_t *vlcObject;
@property (readonly) VLCObjectType objectType;
@property (readonly) int variableType;

@end

@interface NSMenuItem (KeyEquivalentAddition)
- (void)matchKeyEquivalentsOfMenuItem:(NSMenuItem *)menuItem;
@end

@interface VLCMainMenu() <NSMenuDelegate>
{
    VLCAboutWindowController *_aboutWindowController;
    VLCHelpWindowController  *_helpWindowController;
    VLCAddonsWindowController *_addonsController;
    VLCPlayQueueController *_playQueueController;
    VLCPlayerController *_playerController;
    VLCPlayQueueSortingMenuController *_playQueueSortingController;
    VLCInformationWindowController *_infoWindowController;
    VLCRecentStreamsMenuController *_recentStreamsMenuController;

    __strong VLCTimeSelectionPanelController *_timeSelectionPanel;
    __strong VLCCustomCropArWindowController *_customARController;
}

@end

@implementation VLCMainMenu

#pragma mark - Initialization

- (void)dealloc
{
    msg_Dbg(getIntf(), "Deinitializing main menu");
    [NSNotificationCenter.defaultCenter removeObserver: self];

    [self releaseRepresentedObjects:[NSApp mainMenu]];
}

- (void)awakeFromNib
{
    _playQueueController = VLCMain.sharedInstance.playQueueController;
    _playerController = _playQueueController.playerController;

    /* check whether the user runs OSX with a RTL language */
    NSArray *languages = [NSLocale preferredLanguages];
    NSString *preferredLanguage = [languages firstObject];

    if ([NSLocale characterDirectionForLanguage:preferredLanguage] == NSLocaleLanguageDirectionRightToLeft) {
        msg_Dbg(getIntf(), "adapting interface since '%s' is a RTL language", [preferredLanguage UTF8String]);
        [_rateTextField setAlignment:NSTextAlignmentLeft];
    }

#ifdef HAVE_SPARKLE
    [_checkForUpdate setAction:@selector(checkForUpdates:)];
    [_checkForUpdate setTarget:VLCMain.sharedInstance.sparkleUpdaterController];
#else
    [_checkForUpdate setEnabled:NO];
#endif

    [self initStrings];
    [self setupKeyboardShortcuts];

    /* configure playback / controls menu */
    self.fileMenu.delegate = self;
    self.controlsMenu.delegate = self;
    self.audioMenu.delegate = self;
    self.videoMenu.delegate = self;
    self.subtitlesMenu.delegate = self;
    [_rendererNoneItem setState:NSOnState];
    _rendererMenuController = [[VLCRendererMenuController alloc] init];
    _rendererMenuController.rendererNoneItem = _rendererNoneItem;
    _rendererMenuController.rendererMenu = _rendererMenu;
    _rendererMenuController.rendererMenuItem = _rendererMenuItem;
    _playQueueSortingController = [[VLCPlayQueueSortingMenuController alloc] init];
    _sortPlayQueue.submenu = _playQueueSortingController.playQueueSortingMenu;
    _recentStreamsMenuController =
        [[VLCRecentStreamsMenuController alloc] initWithSubmenu:_recent_streamsMenu];

    [self mediaItemChanged:nil];
    [self playbackStateChanged:nil];
    [self updateTitleAndChapterMenus:nil];
    [self updateProgramMenu:nil];
    [self updateLibraryPlayQueueMode];

    NSNotificationCenter *notificationCenter = NSNotificationCenter.defaultCenter;
    [notificationCenter addObserver:self
                           selector:@selector(refreshVoutDeviceMenu:)
                               name:NSApplicationDidChangeScreenParametersNotification
                             object:nil];
    [notificationCenter addObserver:self
                           selector:@selector(updatePlaybackRate)
                               name:VLCPlayerRateChanged
                             object:nil];
    [notificationCenter addObserver:self
                           selector:@selector(updateRecordState)
                               name:VLCPlayerRecordingChanged
                             object:nil];
    [notificationCenter addObserver:self
                           selector:@selector(playbackStateChanged:)
                               name:VLCPlayerStateChanged
                             object:nil];
    [notificationCenter addObserver:self
                           selector:@selector(playModeChanged:)
                               name:VLCPlaybackRepeatChanged
                             object:nil];
    [notificationCenter addObserver:self
                           selector:@selector(playOrderChanged:)
                               name:VLCPlaybackOrderChanged
                             object:nil];
    [notificationCenter addObserver:self
                           selector:@selector(updateTrackHandlingMenus:)
                               name:VLCPlayerTrackListChanged
                             object:nil];
    [notificationCenter addObserver:self
                           selector:@selector(updateTrackHandlingMenus:)
                               name:VLCPlayerTrackSelectionChanged
                             object:nil];
    [notificationCenter addObserver:self
                           selector:@selector(updateTitleAndChapterMenus:)
                               name:VLCPlayerTitleListChanged
                             object:nil];
    [notificationCenter addObserver:self
                           selector:@selector(updateTitleAndChapterMenus:)
                               name:VLCPlayerTitleSelectionChanged
                             object:nil];
    [notificationCenter addObserver:self
                           selector:@selector(updateTitleAndChapterMenus:)
                               name:VLCPlayerChapterSelectionChanged
                             object:nil];
    [notificationCenter addObserver:self
                           selector:@selector(updateProgramMenu:)
                               name:VLCPlayerProgramListChanged
                             object:nil];
    [notificationCenter addObserver:self
                           selector:@selector(updateProgramMenu:)
                               name:VLCPlayerProgramSelectionChanged
                             object:nil];
    [notificationCenter addObserver:self
                           selector:@selector(mediaItemChanged:)
                               name:VLCPlayerCurrentMediaItemChanged
                             object:nil];
    [notificationCenter addObserver:self
                           selector:@selector(voutListChanged:)
                               name:VLCPlayerListOfVideoOutputThreadsChanged
                             object:nil];
    [notificationCenter addObserver:self
                           selector:@selector(updateRateControls:)
                               name:VLCPlayerCapabilitiesChanged
                             object:nil];

    [self setupVarMenuItem:_add_intf
                    target:VLC_OBJECT(getIntf())
                objectType:VLCObjectTypeInterface
                       var:"intf-add"
                  selector:@selector(toggleVar:)];

    /* setup extensions menu */
    /* Let the ExtensionsManager itself build the menu */
    VLCExtensionsManager *extMgr = VLCMain.sharedInstance.extensionsManager;
    [extMgr buildMenu:_extensionsMenu];
    [_extensions setEnabled:([_extensionsMenu numberOfItems] > 0)];

    /* setup post-proc menu */
    [_postprocessingMenu removeAllItems];
    [_postprocessingMenu setAutoenablesItems: YES];
    [_postprocessingMenu addItemWithTitle: _NS("Disable") action:@selector(togglePostProcessing:) keyEquivalent:@""];
    NSMenuItem *mitem = [_postprocessingMenu itemAtIndex: 0];
    [mitem setTag: -1];
    [mitem setEnabled: YES];
    [mitem setTarget: self];
    for (NSUInteger x = 1; x < 7; x++) {
        [_postprocessingMenu addItemWithTitle:[NSString stringWithFormat:_NS("Level %i"), x]
                                       action:@selector(togglePostProcessing:)
                                keyEquivalent:@""];
        mitem = [_postprocessingMenu itemAtIndex:x];
        [mitem setEnabled:YES];
        [mitem setTag:x];
        [mitem setTarget:self];
    }
    char *psz_config = config_GetPsz("video-filter");
    if (psz_config) {
        if (!strstr(psz_config, "postproc"))
            [[_postprocessingMenu itemAtIndex:0] setState:NSOnState];
        else
            [[_postprocessingMenu itemWithTag:config_GetInt("postproc-q")] setState:NSOnState];
        free(psz_config);
    } else
        [[_postprocessingMenu itemAtIndex:0] setState:NSOnState];
    [_postprocessing setEnabled: NO];

    [self refreshAudioDeviceList];

    /* setup subtitles menu */
    [self setupMenu: _subtitle_textcolorMenu withIntList:"freetype-color" andSelector:@selector(switchSubtitleOption:)];
    [_subtitle_bgopacity_sld setIntegerValue: config_GetInt("freetype-background-opacity")];
    [self setupMenu: _subtitle_bgcolorMenu withIntList:"freetype-background-color" andSelector:@selector(switchSubtitleOption:)];
    [self setupMenu: _subtitle_outlinethicknessMenu withIntList:"freetype-outline-thickness" andSelector:@selector(switchSubtitleOption:)];

    [_voutMenuplay matchKeyEquivalentsOfMenuItem:_play];
    [_voutMenustop matchKeyEquivalentsOfMenuItem:_stop];
    [_voutMenunext matchKeyEquivalentsOfMenuItem:_next];
    [_voutMenuprev matchKeyEquivalentsOfMenuItem:_previous];
    [_voutMenuRecord matchKeyEquivalentsOfMenuItem:_record];
    [_voutMenuvolup matchKeyEquivalentsOfMenuItem:_vol_up];
    [_voutMenuvoldown matchKeyEquivalentsOfMenuItem:_vol_down];
    [_voutMenumute matchKeyEquivalentsOfMenuItem:_mute];
    [_voutMenufullscreen matchKeyEquivalentsOfMenuItem:_fullscreenItem];
    [_voutMenusnapshot matchKeyEquivalentsOfMenuItem:_snapshot];

    [self updateVideoSubmenuEnablement];
    [self updateAudioSubmenuEnablement];
    [self updateRecentMenuEnablement];
}

- (void)setupMenu:(NSMenu *)menu withIntList:(char *)psz_name andSelector:(SEL)selector
{
    module_config_t *p_item;

    [menu removeAllItems];
    p_item = config_FindConfig(psz_name);

    if (!p_item) {
        msg_Err(getIntf(), "couldn't create menu int list for item '%s' as it does not exist", psz_name);
        return;
    }

    for (int i = 0; i < p_item->list_count; i++) {
        NSMenuItem *mi;
        if (p_item->list_text != NULL)
            mi = [[NSMenuItem alloc] initWithTitle: NSTR(p_item->list_text[i]) action:NULL keyEquivalent: @""];
        else if (p_item->list.i[i])
            mi = [[NSMenuItem alloc] initWithTitle: [NSString stringWithFormat: @"%d", p_item->list.i[i]] action:NULL keyEquivalent: @""];
        else {
            msg_Err(getIntf(), "item %d of pref %s failed to be created", i, psz_name);
            continue;
        }

        [mi setTarget:self];
        [mi setAction:selector];
        [mi setTag:p_item->list.i[i]];
        [mi setRepresentedObject:toNSStr(psz_name)];
        [menu addItem:mi];
        if (p_item->value.i == p_item->list.i[i])
            [mi setState:NSOnState];
    }
}

- (void)initStrings
{
    /* main menu */
    [_about setTitle: _NS("About VLC media player...")];
    [_checkForUpdate setTitle: _NS("Check for Updates...")];
    [_prefs setTitle: _NS("Preferences...")];
    [_extensions setTitle: _NS("Extensions")];
    [_extensionsMenu setTitle: _NS("Extensions")];
    [_addonManager setTitle: _NS("Addons Manager")];
    [_add_intf setTitle: _NS("Add Interface")];
    [_add_intfMenu setTitle: _NS("Add Interface")];
    [_services setTitle: _NS("Services")];
    [_hide setTitle: _NS("Hide VLC")];
    [_hide_others setTitle: _NS("Hide Others")];
    [_show_all setTitle: _NS("Show All")];
    [_quit setTitle: _NS("Quit VLC")];

    /* this special case is needed to due to archaic legacy translations of the File menu
     * on the Mac to the German translation which resulted in 'Ablage' instead of 'Datei'.
     * This remains until the present day and does not affect the Windows world. */
     /* xgettext: Label for the macOS main "File" menu */
    [_fileMenu setTitle: _PNS("macOS MainMenu", "File")];
    [_open_generic setTitle: _NS("Advanced Open File...")];
    [_open_file setTitle: _NS("Open File...")];
    [_open_disc setTitle: _NS("Open Disc...")];
    [_open_net setTitle: _NS("Open Stream...")];
    [_open_capture setTitle: _NS("Open Capture Device...")];
    [_connect_to_server setTitle: _NS("Connect to Server...")];
    [_open_recent setTitle: _NS("Open Recent")];
    [_recent_streams setTitle: _NS("Recent Streams")];
    [_close_window setTitle: _NS("Close Window")];
    [_convertandsave setTitle: _NS("Convert / Stream...")];
    [_save_playlist setTitle: _NS("Save Playlist...")];
    [_savePlayqueueToLibrary setTitle: _NS("Save Play Queue to Library...")];
    [_revealInFinder setTitle: _NS("Reveal in Finder")];

    [_editMenu setTitle: _NS("Edit")];
    [_cutItem setTitle: _NS("Cut")];
    [_mcopyItem setTitle: _NS("Copy")];
    [_pasteItem setTitle: _NS("Paste")];
    [_clearItem setTitle: _NS("Delete")];
    [_select_all setTitle: _NS("Select All")];
    [_findItem setTitle: _NS("Find")];

    [_viewMenu setTitle: _NS("View")];

    [_controlsMenu setTitle: _NS("Playback")];
    [_play setTitle: _NS("Play")];
    [_stop setTitle: _NS("Stop")];
    [_record setTitle: _NS("Record")];
    [_rate_view setAutoresizingMask:NSViewWidthSizable];
    [_rate setView: _rate_view];
    [_rateLabel setStringValue: _NS("Playback Speed")];
    [_rate_slowerLabel setStringValue: _NS("Slower")];
    [_rate_normalLabel setStringValue: _NS("Normal")];
    [_rate_fasterLabel setStringValue: _NS("Faster")];
    [_trackSynchronization setTitle: _NS("Track Synchronization")];
    [_previous setTitle: _NS("Previous")];
    [_next setTitle: _NS("Next")];
    [_random setTitle: _NS("Random")];
    [_repeat setTitle: _NS("Repeat")];
    [_AtoBloop setTitle: _NS("A→B Loop")];
    [_lyrics setTitle: _NS("Lyrics")];
    [_libraryPlayQueueMode setTitle: _NS("Library Play Queue Mode")];
    [_sortPlayQueue setTitle: _NS("Sort Play Queue")];
    [_quitAfterPB setTitle: _NS("Quit after Playback")];
    [_fwd setTitle: _NS("Step Forward")];
    [_bwd setTitle: _NS("Step Backward")];
    [_jumpToTime setTitle: _NS("Jump to Time")];
    [_rendererMenuItem setTitle:_NS("Renderer")];
    [_rendererNoneItem setTitle:_NS("No renderer")];
    [_program setTitle: _NS("Program")];
    [_programMenu setTitle: _NS("Program")];
    [_title setTitle: _NS("Title")];
    [_titleMenu setTitle: _NS("Title")];
    [_chapter setTitle: _NS("Chapter")];
    [_chapterMenu setTitle: _NS("Chapter")];

    [_audioMenu setTitle: _NS("Audio")];
    [_vol_up setTitle: _NS("Increase Volume")];
    [_vol_down setTitle: _NS("Decrease Volume")];
    [_mute setTitle: _NS("Mute")];
    [_audiotrack setTitle: _NS("Audio Track")];
    [_audiotrackMenu setTitle: _NS("Audio Track")];
    [_channels setTitle: _NS("Stereo audio mode")];
    [_channelsMenu setTitle: _NS("Stereo audio mode")];
    [_audioDevice setTitle: _NS("Audio Device")];
    [_audioDeviceMenu setTitle: _NS("Audio Device")];
    [_visual setTitle: _NS("Visualizations")];
    [_visualMenu setTitle: _NS("Visualizations")];

    [_videoMenu setTitle: _NS("Video")];
    [_half_window setTitle: _NS("Half Size")];
    [_normal_window setTitle: _NS("Normal Size")];
    [_double_window setTitle: _NS("Double Size")];
    [_fittoscreen setTitle: _NS("Fit to Screen")];
    [_fullscreenItem setTitle: _NS("Fullscreen")];
    [_floatontop setTitle: _NS("Float on Top")];
    [_snapshot setTitle: _NS("Snapshot")];
    [_videotrack setTitle: _NS("Video Track")];
    [_videotrackMenu setTitle: _NS("Video Track")];
    [_aspect_ratio setTitle: _NS("Aspect ratio")];
    [_aspect_ratioMenu setTitle: _NS("Aspect ratio")];
    [_crop setTitle: _NS("Crop")];
    [_cropMenu setTitle: _NS("Crop")];
    [_screen setTitle: _NS("Fullscreen Video Device")];
    [_screenMenu setTitle: _NS("Fullscreen Video Device")];
    [_deinterlace setTitle: _NS("Deinterlace")];
    [_deinterlaceMenu setTitle: _NS("Deinterlace")];
    [_deinterlace_mode setTitle: _NS("Deinterlace mode")];
    [_deinterlace_modeMenu setTitle: _NS("Deinterlace mode")];
    [_postprocessing setTitle: _NS("Post processing")];
    [_postprocessingMenu setTitle: _NS("Post processing")];

    [_subtitlesMenu setTitle:_NS("Subtitles")];
    [_openSubtitleFile setTitle: _NS("Add Subtitle File...")];
    [_subtitle_track setTitle: _NS("Subtitles Track")];
    [_subtitle_tracksMenu setTitle: _NS("Subtitles Track")];
    [_subtitleSizeView setAutoresizingMask: NSViewWidthSizable];
    [_subtitleSize setView: _subtitleSizeView];
    [_subtitleSizeLabel setStringValue: _NS("Subtitles Size")];
    [_subtitleSizeSmallerLabel setStringValue: _NS("Smaller")];
    [_subtitleSizeLargerLabel setStringValue: _NS("Larger")];
    [_subtitle_textcolor setTitle: _NS("Text Color")];
    [_subtitle_outlinethickness setTitle: _NS("Outline Thickness")];

    // Autoresizing with constraints does not work on 10.7,
    // translate autoresizing mask to constriaints for now
    [_subtitle_bgopacity_view setAutoresizingMask:NSViewWidthSizable];
    [_subtitle_bgopacity setView: _subtitle_bgopacity_view];
    [_subtitle_bgopacityLabel setStringValue: _NS("Background Opacity")];
    [_subtitle_bgopacityLabel_gray setStringValue: _NS("Background Opacity")];
    [_subtitle_bgcolor setTitle: _NS("Background Color")];
    [_teletext setTitle: _NS("Teletext")];
    [_teletext_transparent setTitle: _NS("Transparent")];
    [_teletext_index setTitle: _NS("Index")];
    [_teletext_red setTitle: _NS("Red")];
    [_teletext_green setTitle: _NS("Green")];
    [_teletext_yellow setTitle: _NS("Yellow")];
    [_teletext_blue setTitle: _NS("Blue")];

    [_windowMenu setTitle: _NS("Window")];
    [_minimize setTitle: _NS("Minimize")];
    [_zoom_window setTitle: _NS("Zoom")];
    [_player setTitle: _NS("Player...")];
    [_controller setTitle: _NS("Main Window...")];
    [_audioeffects setTitle: _NS("Audio Effects...")];
    [_videoeffects setTitle: _NS("Video Effects...")];
    [_bookmarks setTitle: _NS("Bookmarks...")];
    [_playQueue setTitle: _NS("Play Queue...")];

    [_detachedAudioWindow setTitle: _NS("Detached Audio Window...")];
    [_info setTitle: _NS("Media Information...")];
    [_messages setTitle: _NS("Messages...")];
    [_errorsAndWarnings setTitle: _NS("Errors and Warnings...")];

    [_bring_atf setTitle: _NS("Bring All to Front")];

    [_helpMenu setTitle: _NS("Help")];
    [_help setTitle: _NS("VLC media player Help...")];
    [_license setTitle: _NS("License")];
    [_documentation setTitle: _NS("Online Documentation...")];
    [_website setTitle: _NS("VideoLAN Website...")];
    [_donation setTitle: _NS("Make a donation...")];
    [_forum setTitle: _NS("Online Forum...")];

    /* dock menu */
    [_dockMenuplay setTitle: _NS("Play")];
    [_dockMenustop setTitle: _NS("Stop")];
    [_dockMenunext setTitle: _NS("Next")];
    [_dockMenuprevious setTitle: _NS("Previous")];
    [_dockMenumute setTitle: _NS("Mute")];

    /* vout menu */
    [_voutMenuplay setTitle: _NS("Play")];
    [_voutMenustop setTitle: _NS("Stop")];
    [_voutMenuprev setTitle: _NS("Previous")];
    [_voutMenunext setTitle: _NS("Next")];
    [_voutMenuvolup setTitle: _NS("Volume Up")];
    [_voutMenuvoldown setTitle: _NS("Volume Down")];
    [_voutMenumute setTitle: _NS("Mute")];
    [_voutMenuAudiotrack setTitle: _NS("Audio Track")];
    [_voutMenuAudiotrackMenu setTitle: _NS("Audio Track")];
    [_voutMenuVideotrack setTitle: _NS("Video Track")];
    [_voutMenuVideotrackMenu setTitle: _NS("Video Track")];
    [_voutMenuOpenSubtitleFile setTitle:_NS("Add Subtitle File...")];
    [_voutMenuSubtitlestrack setTitle: _NS("Subtitles Track")];
    [_voutMenuSubtitlestrackMenu setTitle: _NS("Subtitles Track")];
    [_voutMenufullscreen setTitle: _NS("Fullscreen")];
    [_voutMenusnapshot setTitle: _NS("Snapshot")];

    /* File menu */
    [_open_generic vlc_setActionImageWithSystemSymbolName:@"doc.badge.ellipsis"];
    [_open_file vlc_setActionImageWithSystemSymbolName:@"doc"];
    [_open_disc vlc_setActionImageWithSystemSymbolName:@"opticaldisc"];
    [_open_net vlc_setActionImageWithSystemSymbolName:@"antenna.radiowaves.left.and.right"];
    [_open_capture vlc_setActionImageWithSystemSymbolName:@"camera.viewfinder"];
    [_connect_to_server vlc_setActionImageWithSystemSymbolName:@"server.rack"];
    [_revealInFinder vlc_setActionImageWithSystemSymbolName:@"folder"];
    [_save_playlist vlc_setActionImageWithSystemSymbolName:@"square.and.arrow.down"];
    [_convertandsave vlc_setActionImageWithSystemSymbolName:@"arrow.triangle.2.circlepath"];

    /* Playback menu */
    [_play vlc_setActionImageWithSystemSymbolName:@"play.fill"];
    [_stop vlc_setActionImageWithSystemSymbolName:@"stop.fill"];
    [_record vlc_setActionImageWithSystemSymbolName:@"record.circle"];
    [_previous vlc_setActionImageWithSystemSymbolName:@"backward.end.fill"];
    [_next vlc_setActionImageWithSystemSymbolName:@"forward.end.fill"];
    [_fwd vlc_setActionImageWithSystemSymbolName:@"goforward.10"];
    [_bwd vlc_setActionImageWithSystemSymbolName:@"gobackward.10"];
    [_random vlc_setActionImageWithSystemSymbolName:@"shuffle"];
    [_repeat vlc_setActionImageWithSystemSymbolName:@"repeat"];
    [_AtoBloop vlc_setActionImageWithSystemSymbolName:@"repeat.1"];
    [_jumpToTime vlc_setActionImageWithSystemSymbolName:@"timer"];
    [_sortPlayQueue vlc_setActionImageWithSystemSymbolName:@"arrow.up.arrow.down"];
    [_lyrics vlc_setActionImageWithSystemSymbolName:@"text.quote"];

    /* Audio menu */
    [_vol_up vlc_setActionImageWithSystemSymbolName:@"speaker.wave.3.fill"];
    [_vol_down vlc_setActionImageWithSystemSymbolName:@"speaker.wave.1.fill"];
    [_mute vlc_setActionImageWithSystemSymbolName:@"speaker.slash.fill"];
    [_audiotrack vlc_setActionImageWithSystemSymbolName:@"waveform"];
    [_channels vlc_setActionImageWithSystemSymbolName:@"speaker.2.fill"];
    [_audioDevice vlc_setActionImageWithSystemSymbolName:@"airplay.audio"];
    [_visual vlc_setActionImageWithSystemSymbolName:@"music.note.tv"];

    /* Video menu */
    [_fullscreenItem vlc_setActionImageWithSystemSymbolName:@"arrow.up.left.and.arrow.down.right"];
    [_snapshot vlc_setActionImageWithSystemSymbolName:@"camera"];
    [_floatontop vlc_setActionImageWithSystemSymbolName:@"square.3.layers.3d.top.filled"];
    [_videotrack vlc_setActionImageWithSystemSymbolName:@"video"];

    /* Subtitles menu */
    [_openSubtitleFile vlc_setActionImageWithSystemSymbolName:@"captions.bubble"];
    [_subtitle_track vlc_setActionImageWithSystemSymbolName:@"text.bubble"];

    /* Window menu */
    [_info vlc_setActionImageWithSystemSymbolName:@"info.circle"];
    [_audioeffects vlc_setActionImageWithSystemSymbolName:@"slider.horizontal.3"];
    [_videoeffects vlc_setActionImageWithSystemSymbolName:@"wand.and.sparkles"];
    [_bookmarks vlc_setActionImageWithSystemSymbolName:@"bookmark"];
    [_playQueue vlc_setActionImageWithSystemSymbolName:@"list.bullet"];

    /* Vout context menu */
    [_voutMenuplay vlc_setActionImageWithSystemSymbolName:@"play.fill"];
    [_voutMenustop vlc_setActionImageWithSystemSymbolName:@"stop.fill"];
    [_voutMenuRecord vlc_setActionImageWithSystemSymbolName:@"record.circle"];
    [_voutMenuprev vlc_setActionImageWithSystemSymbolName:@"backward.end.fill"];
    [_voutMenunext vlc_setActionImageWithSystemSymbolName:@"forward.end.fill"];
    [_voutMenuvolup vlc_setActionImageWithSystemSymbolName:@"speaker.wave.3.fill"];
    [_voutMenuvoldown vlc_setActionImageWithSystemSymbolName:@"speaker.wave.1.fill"];
    [_voutMenumute vlc_setActionImageWithSystemSymbolName:@"speaker.slash.fill"];
    [_voutMenuAudiotrack vlc_setActionImageWithSystemSymbolName:@"waveform"];
    [_voutMenuVideotrack vlc_setActionImageWithSystemSymbolName:@"video"];
    [_voutMenuOpenSubtitleFile vlc_setActionImageWithSystemSymbolName:@"captions.bubble"];
    [_voutMenuSubtitlestrack vlc_setActionImageWithSystemSymbolName:@"text.bubble"];
    [_voutMenufullscreen vlc_setActionImageWithSystemSymbolName:@"arrow.up.left.and.arrow.down.right"];
    [_voutMenusnapshot vlc_setActionImageWithSystemSymbolName:@"camera"];
}

- (void)setupKeyboardShortcuts
{
    char *key;

    key = config_GetPsz("key-quit");
    [_quit setKeyEquivalent: VLCKeyToString(key)];
    [_quit setKeyEquivalentModifierMask: VLCModifiersToCocoa(key)];
    FREENULL(key);

    // do not assign play/pause key

    key = config_GetPsz("key-stop");
    [_stop setKeyEquivalent: VLCKeyToString(key)];
    [_stop setKeyEquivalentModifierMask: VLCModifiersToCocoa(key)];
    FREENULL(key);

    key = config_GetPsz("key-prev");
    [_previous setKeyEquivalent: VLCKeyToString(key)];
    [_previous setKeyEquivalentModifierMask: VLCModifiersToCocoa(key)];
    FREENULL(key);

    key = config_GetPsz("key-next");
    [_next setKeyEquivalent: VLCKeyToString(key)];
    [_next setKeyEquivalentModifierMask: VLCModifiersToCocoa(key)];
    FREENULL(key);

    key = config_GetPsz("key-jump+short");
    [_fwd setKeyEquivalent: VLCKeyToString(key)];
    [_fwd setKeyEquivalentModifierMask: VLCModifiersToCocoa(key)];
    FREENULL(key);

    key = config_GetPsz("key-jump-short");
    [_bwd setKeyEquivalent: VLCKeyToString(key)];
    [_bwd setKeyEquivalentModifierMask: VLCModifiersToCocoa(key)];
    FREENULL(key);

    key = config_GetPsz("key-vol-up");
    [_vol_up setKeyEquivalent: VLCKeyToString(key)];
    [_vol_up setKeyEquivalentModifierMask: VLCModifiersToCocoa(key)];
    FREENULL(key);

    key = config_GetPsz("key-vol-down");
    [_vol_down setKeyEquivalent: VLCKeyToString(key)];
    [_vol_down setKeyEquivalentModifierMask: VLCModifiersToCocoa(key)];
    FREENULL(key);

    key = config_GetPsz("key-vol-mute");
    [_mute setKeyEquivalent: VLCKeyToString(key)];
    [_mute setKeyEquivalentModifierMask: VLCModifiersToCocoa(key)];
    FREENULL(key);

    key = config_GetPsz("key-toggle-fullscreen");
    [_fullscreenItem setKeyEquivalent: VLCKeyToString(key)];
    [_fullscreenItem setKeyEquivalentModifierMask: VLCModifiersToCocoa(key)];
    FREENULL(key);

    key = config_GetPsz("key-snapshot");
    [_snapshot setKeyEquivalent: VLCKeyToString(key)];
    [_snapshot setKeyEquivalentModifierMask: VLCModifiersToCocoa(key)];
    FREENULL(key);

    key = config_GetPsz("key-random");
    [_random setKeyEquivalent: VLCKeyToString(key)];
    [_random setKeyEquivalentModifierMask: VLCModifiersToCocoa(key)];
    FREENULL(key);

    key = config_GetPsz("key-loop");
    [_repeat setKeyEquivalent: VLCKeyToString(key)];
    [_repeat setKeyEquivalentModifierMask: VLCModifiersToCocoa(key)];
    FREENULL(key);

    key = config_GetPsz("key-zoom-half");
    [_half_window setKeyEquivalent: VLCKeyToString(key)];
    [_half_window setKeyEquivalentModifierMask: VLCModifiersToCocoa(key)];
    FREENULL(key);

    key = config_GetPsz("key-zoom-original");
    [_normal_window setKeyEquivalent: VLCKeyToString(key)];
    [_normal_window setKeyEquivalentModifierMask: VLCModifiersToCocoa(key)];
    FREENULL(key);

    key = config_GetPsz("key-zoom-double");
    [_double_window setKeyEquivalent: VLCKeyToString(key)];
    [_double_window setKeyEquivalentModifierMask: VLCModifiersToCocoa(key)];
    FREENULL(key);
}

#pragma mark - Termination

- (void)releaseRepresentedObjects:(NSMenu *)the_menu
{
    NSArray *menuitems_array = [the_menu itemArray];
    NSUInteger menuItemCount = [menuitems_array count];
    for (NSUInteger i=0; i < menuItemCount; i++) {
        NSMenuItem *one_item = [menuitems_array objectAtIndex:i];
        if ([one_item hasSubmenu])
            [self releaseRepresentedObjects: [one_item submenu]];

        [one_item setRepresentedObject:NULL];
    }
}

#pragma mark - Interface update

- (void)updateVideoSubmenuEnablement
{
    vout_thread_t * const p_vout = _playerController.videoOutputThreadForKeyWindow;
    const BOOL enabled = p_vout != NULL &&
                         _playerController.currentMedia != nil &&
                         _playerController.activeVideoPlayback;

    _aspect_ratio.enabled = enabled;
    _crop.enabled = enabled;
    _deinterlace.enabled = enabled;
    _deinterlace_mode.enabled = enabled;
    _postprocessing.enabled = enabled;
    _screen.enabled = enabled;
    _videotrack.enabled = enabled && _playerController.videoTracks.count > 0;

    if (p_vout != NULL)
        vout_Release(p_vout);
}

- (void)updateAudioSubmenuEnablement
{
    audio_output_t * const p_aout = _playerController.mainAudioOutput;
    const BOOL enabled = p_aout != NULL &&
                         _playerController.currentMedia != nil &&
                         _playerController.playerState != VLC_PLAYER_STATE_STOPPED;

    _audiotrack.enabled = enabled && _playerController.audioTracks.count > 0;
    _channels.enabled = enabled;
    _visual.enabled = enabled;

    if (p_aout != NULL)
        aout_Release(p_aout);
}

- (void)updateRecentMenuEnablement
{
    _open_recent.enabled = NSDocumentController.sharedDocumentController.recentDocumentURLs.count > 0;
    _recent_streams.enabled = _recentStreamsMenuController.hasEntries;
}

- (void)mediaItemChanged:(NSNotification *)notification
{
    [self updateTrackHandlingMenus:notification];
    [self updateRateControls:notification];

    if (_playerController.currentMedia != nil) {
        [self rebuildAoutMenu];
        [self rebuildVoutMenu];
    }

    [self updateVideoSubmenuEnablement];
    [self updateAudioSubmenuEnablement];
}

- (void)rebuildAoutMenu
{
    audio_output_t *p_aout = [_playerController mainAudioOutput];
    if (!p_aout) {
        return;
    }
    [self setupVarMenuItem:_channels
                    target:VLC_OBJECT(p_aout)
                objectType:VLCObjectTypeAout
                       var:"stereo-mode"
                  selector:@selector(toggleVar:)];

    [self setupVarMenuItem:_visual
                    target:VLC_OBJECT(p_aout)
                objectType:VLCObjectTypeAout
                       var:"visual"
                  selector:@selector(toggleVar:)];
    aout_Release(p_aout);
}

- (void)voutListChanged:(NSNotification *)aNotification
{
    [self rebuildVoutMenu];
    [self updateVideoSubmenuEnablement];
}

- (void)rebuildVoutMenu
{
    vout_thread_t *p_vout = [_playerController videoOutputThreadForKeyWindow];
    if (!p_vout) {
        return;
    }

    [self setupVarMenuItem:_aspect_ratio
                    target:VLC_OBJECT(p_vout)
                objectType:VLCObjectTypeVout
                       var:"aspect-ratio"
                  selector:@selector(toggleVar:)];
    [self appendCustomizationItem:_aspect_ratio];

    [self setupVarMenuItem:_crop
                    target:VLC_OBJECT(p_vout)
                objectType:VLCObjectTypeVout
                       var:"crop"
                  selector:@selector(toggleVar:)];
    [self appendCustomizationItem:_crop];

    [self setupVarMenuItem:_deinterlace
                    target:VLC_OBJECT(p_vout)
                objectType:VLCObjectTypeVout
                       var:"deinterlace"
                  selector:@selector(toggleVar:)];

    [self setupVarMenuItem:_deinterlace_mode
                    target:VLC_OBJECT(p_vout)
                objectType:VLCObjectTypeVout
                       var:"deinterlace-mode"
                  selector:@selector(toggleVar:)];

    vout_Release(p_vout);

    [self refreshVoutDeviceMenu:nil];
}

- (void)refreshVoutDeviceMenu:(NSNotification *)notification
{
    NSMenu *submenu = _screenMenu;
    [submenu removeAllItems];

    NSArray *screens = [NSScreen screens];
    NSMenuItem *menuItem;
    NSUInteger numberOfScreens = [screens count];
    [_screen setEnabled: YES];
    [submenu addItemWithTitle: _NS("Default") action:@selector(toggleFullscreenDevice:) keyEquivalent:@""];
    menuItem = [submenu itemAtIndex: 0];
    [menuItem setTag: 0];
    [menuItem setEnabled: YES];
    [menuItem setTarget: self];
    NSRect s_rect;
    for (NSUInteger i = 0; i < numberOfScreens; i++) {
        NSScreen *screen = [screens objectAtIndex:i];
        s_rect = [screen frame];
        [submenu addItemWithTitle:[NSString stringWithFormat: @"%@ %li (%ix%i)", _NS("Screen"), i+1, (int)s_rect.size.width, (int)s_rect.size.height]
                           action:@selector(toggleFullscreenDevice:)
                    keyEquivalent:@""];
        menuItem = [submenu itemAtIndex:i+1];
        [menuItem setTag:(int)[screen displayID]];
        [menuItem setEnabled: YES];
        [menuItem setTarget: self];
    }
    [[submenu itemWithTag: var_InheritInteger(getIntf(), "macosx-vdev")] setState: NSOnState];
    [self updateVideoSubmenuEnablement];
}

- (void)updateSubtitlesMenu:(NSNotification *)notification
{
    const BOOL enabled = [self validateUserInterfaceItem:self.openSubtitleFile];
    const BOOL hasSubtitleTracks = _playerController.subtitleTracks.count > 0;

    self.subtitleSize.enabled = enabled;
    self.subtitle_track.enabled = enabled && hasSubtitleTracks;
    self.subtitle_textcolor.enabled = enabled;
    self.subtitle_outlinethickness.enabled = enabled;
    self.subtitle_bgopacity.enabled = enabled;
    self.subtitle_bgcolor.enabled = enabled;
    self.teletext.enabled = enabled && _playerController.teletextMenuAvailable;

    self.subtitleSizeSlider.enabled = enabled;

    const unsigned int scaleFactor = _playerController.subtitleTextScalingFactor;
    self.subtitleSizeSlider.intValue = scaleFactor;
    self.subtitleSizeTextField.stringValue =
        [NSString stringWithFormat:@"%.2fx", scaleFactor / 100.];

    NSColor * const color = enabled
        ? NSColor.controlTextColor
        : NSColor.disabledControlTextColor;
    self.subtitleSizeLabel.textColor = color;
    self.subtitleSizeSmallerLabel.textColor = color;
    self.subtitleSizeLargerLabel.textColor = color;
    self.subtitleSizeTextField.textColor = color;

    self.subtitle_bgopacityLabel_gray.hidden = enabled;
    self.subtitle_bgopacityLabel.hidden = !enabled;
    self.subtitle_bgopacity_sld.enabled = enabled;
}

- (void)updateRateControls:(NSNotification *)notification
{
    const BOOL enabled = [self validateUserInterfaceItem:self.rate];
    self.rate_sld.enabled = enabled;

    NSColor * const color = enabled
        ? NSColor.controlTextColor
        : NSColor.disabledControlTextColor;

    self.rateLabel.textColor = color;
    self.rate_slowerLabel.textColor = color;
    self.rate_normalLabel.textColor = color;
    self.rate_fasterLabel.textColor = color;
    self.rateTextField.textColor = color;
}

#pragma mark - View

#pragma mark - Playback

- (IBAction)play:(id)sender
{
    [_playerController togglePlayPause];
}

- (IBAction)stop:(id)sender
{
    [_playerController stop];
}

- (IBAction)prev:(id)sender
{
    [_playQueueController playPreviousItem];
}

- (IBAction)next:(id)sender
{
    [_playQueueController playNextItem];
}

- (IBAction)random:(id)sender
{
    if (_playQueueController.playbackOrder == VLC_PLAYLIST_PLAYBACK_ORDER_RANDOM) {
        _playQueueController.playbackOrder = VLC_PLAYLIST_PLAYBACK_ORDER_NORMAL;
    } else {
        _playQueueController.playbackOrder = VLC_PLAYLIST_PLAYBACK_ORDER_RANDOM;
    }
}

- (IBAction)repeat:(id)sender
{
    if (_playQueueController.playbackRepeat == VLC_PLAYLIST_PLAYBACK_REPEAT_CURRENT) {
        _playQueueController.playbackRepeat = VLC_PLAYLIST_PLAYBACK_REPEAT_ALL;
    } else if (_playQueueController.playbackRepeat == VLC_PLAYLIST_PLAYBACK_REPEAT_ALL) {
        _playQueueController.playbackRepeat = VLC_PLAYLIST_PLAYBACK_REPEAT_NONE;
    } else {
        _playQueueController.playbackRepeat = VLC_PLAYLIST_PLAYBACK_REPEAT_CURRENT;
    }
}

- (IBAction)forward:(id)sender
{
    [_playerController jumpForwardShort];
}

- (IBAction)backward:(id)sender
{
    [_playerController jumpBackwardShort];
}

- (IBAction)volumeUp:(id)sender
{
    [_playerController incrementVolume];
}

- (IBAction)volumeDown:(id)sender
{
    [_playerController decrementVolume];
}

- (IBAction)mute:(id)sender
{
    [_playerController toggleMute];
}

- (void)lockVideosAspectRatio:(id)sender
{
    [_playerController setAspectRatioIsLocked: ![sender state]];
    [sender setState: [_playerController aspectRatioIsLocked]];
}

- (IBAction)quitAfterPlayback:(id)sender
{
    if (_playQueueController.actionAfterStop != VLC_PLAYLIST_MEDIA_STOPPED_EXIT) {
        _playQueueController.actionAfterStop = VLC_PLAYLIST_MEDIA_STOPPED_EXIT;
    } else {
        _playQueueController.actionAfterStop = VLC_PLAYLIST_MEDIA_STOPPED_CONTINUE;
    }
}

- (IBAction)toggleRecord:(id)sender
{
    [_playerController toggleRecord];
}

- (void)updateRecordState
{
    NSControlStateValue state = _playerController.enableRecording ? NSOnState : NSOffState;
    [_record setState:state];
    [_voutMenuRecord setState:state];
}

- (IBAction)setPlaybackRate:(id)sender
{
    double speed =  pow(2, (double)[_rate_sld intValue] / 17);
    _playerController.playbackRate = speed;
    [_rateTextField setStringValue: [NSString stringWithFormat:@"%.2fx", speed]];
}

- (void)updatePlaybackRate
{
    double playbackRate = _playerController.playbackRate;
    double value = 17 * log(playbackRate) / log(2.);
    int intValue = (int) ((value > 0) ? value + .5 : value - .5);

    if (intValue < -34)
        intValue = -34;
    else if (intValue > 34)
        intValue = 34;

    [_rateTextField setStringValue: [NSString stringWithFormat:@"%.2fx", playbackRate]];
    [_rate_sld setIntValue: intValue];
}

- (IBAction)toggleAtoBloop:(id)sender
{
    [_playerController setABLoop];
}

- (IBAction)toggleLyrics:(id)sender
{
    _playerController.showLyrics = !_playerController.showLyrics;
}

- (IBAction)toggleLibraryPlayQueueMode:(id)sender
{
    _playQueueController.libraryPlayQueueMode = !_playQueueController.libraryPlayQueueMode;
    [self updateLibraryPlayQueueMode];
}

- (void)updateLibraryPlayQueueMode
{
    const BOOL mlAvailable = VLCMain.sharedInstance.libraryController.libraryModel != nil;
    const BOOL libraryPlayQueueMode = _playQueueController.libraryPlayQueueMode;
    _libraryPlayQueueMode.state = libraryPlayQueueMode && mlAvailable ? NSControlStateValueOn : NSControlStateValueOff;
}

- (IBAction)goToSpecificTime:(id)sender
{
    if (!_timeSelectionPanel) {
        _timeSelectionPanel = [[VLCTimeSelectionPanelController alloc] init];
    }
    vlc_tick_t length = _playerController.length;
    [_timeSelectionPanel setMaxTime:(int)SEC_FROM_VLC_TICK(length)];
    vlc_tick_t time = _playerController.time;
    [_timeSelectionPanel setJumpTotalSecs:(int)SEC_FROM_VLC_TICK(time)];
    [_timeSelectionPanel runModalForWindow:[NSApp mainWindow]
                         completionHandler:^(NSInteger returnCode, int64_t returnTime) {
                             if (returnCode != NSModalResponseOK)
                                 return;
                             [self->_playerController setTimePrecise:vlc_tick_from_sec(returnTime)];
                         }];
}

- (IBAction)selectRenderer:(id)sender
{
    [_rendererMenuController selectRenderer:sender];
}

#pragma mark - track handling
- (void)updateTrackHandlingMenus:(NSNotification *)notification
{
    NSArray * const audioTracks = _playerController.audioTracks;
    const NSUInteger numberOfAudioTracks = audioTracks.count;
    [self rebuildTracksMenu:self.audiotrackMenu
               withMetadata:audioTracks
                      count:numberOfAudioTracks
                   category:AUDIO_ES];
    [self rebuildTracksMenu:self.voutMenuAudiotrackMenu
               withMetadata:audioTracks
                      count:numberOfAudioTracks
                   category:AUDIO_ES];

    NSArray * const videoTracks = _playerController.videoTracks;
    const NSUInteger numberOfVideoTracks = videoTracks.count;
    [self rebuildTracksMenu:self.videotrackMenu
               withMetadata:videoTracks
                      count:numberOfVideoTracks
                   category:VIDEO_ES];
    [self rebuildTracksMenu:self.voutMenuVideotrackMenu
               withMetadata:videoTracks
                      count:numberOfVideoTracks
                   category:VIDEO_ES];

    NSArray * const subtitleTracks = _playerController.subtitleTracks;
    const NSUInteger numberOfSubtitleTracks = subtitleTracks.count;
    [self rebuildTracksMenu:self.subtitle_tracksMenu
               withMetadata:subtitleTracks
                      count:numberOfSubtitleTracks
                   category:SPU_ES];
    [self rebuildTracksMenu:self.voutMenuSubtitlestrackMenu
               withMetadata:subtitleTracks
                      count:numberOfSubtitleTracks
                   category:SPU_ES];

    [self updateSubtitlesMenu:notification];
    [self updateVideoSubmenuEnablement];
    [self updateAudioSubmenuEnablement];
}

- (void)rebuildTracksMenu:(NSMenu *)menu
             withMetadata:(NSArray *)metadataArray
                    count:(size_t)count
                 category:(enum es_format_category_e)category
{
    [menu removeAllItems];
    BOOL itemSelected = NO;

    NSMenuItem *menuItem = [[NSMenuItem alloc] initWithTitle:_NS("Disable")
                                                      action:@selector(unselectTrackCategory:)
                                               keyEquivalent:@""];
    [menuItem setTarget:self];
    [menuItem setTag:category];
    [menuItem setEnabled:YES];
    [menu addItem:menuItem];

    for (VLCTrackMetaData *metaDataItem in metadataArray) {
        menuItem = [[NSMenuItem alloc] initWithTitle:metaDataItem.name
                                              action:@selector(selectTrack:)
                                       keyEquivalent:@""];
        [menuItem setTarget:self];
        [menuItem setRepresentedObject:metaDataItem];
        [menuItem setEnabled:YES];
        if (metaDataItem.selected) {
            itemSelected = YES;
            [menuItem setState:NSOnState];
        } else {
            [menuItem setState:NSOffState];
        }
        [menu addItem:menuItem];
    }

    /* select the "Disabled" item in case no track is selected */
    if (!itemSelected) {
        [menu.itemArray.firstObject setState:NSOnState];
    }
}

- (void)selectTrack:(NSMenuItem *)sender
{
    NSEvent *currentEvent = [NSApp currentEvent];
    [_playerController selectTrack:[sender representedObject] exclusively:!(currentEvent.modifierFlags & NSEventModifierFlagOption)];
}

- (void)unselectTrackCategory:(NSMenuItem *)sender
{
    [_playerController unselectTracksFromCategory:(enum es_format_category_e)sender.tag];
}

#pragma mark - title and chapter handling
- (void)updateTitleAndChapterMenus:(NSNotification *)aNotification
{
    [_titleMenu removeAllItems];
    [_chapterMenu removeAllItems];

    size_t count = [_playerController numberOfTitlesOfCurrentMedia];
    size_t selectedIndex = [_playerController selectedTitleIndex];
    for (size_t x = 0; x < count; x++) {
        const struct vlc_player_title *p_title = [_playerController titleAtIndexForCurrentMedia:x];
        if (p_title == NULL) {
            break;
        }
        NSMenuItem *menuItem = [[NSMenuItem alloc] initWithTitle:toNSStr(p_title->name)
                                                          action:@selector(selectTitle:)
                                                   keyEquivalent:@""];
        [menuItem setTarget:self];
        [menuItem setTag:x];
        [menuItem setEnabled:YES];
        [menuItem setState: x == selectedIndex ? NSOnState : NSOffState];
        [_titleMenu addItem:menuItem];
    }
    _title.enabled = count > 0 ? YES : NO;

    count = [_playerController numberOfChaptersForCurrentTitle];
    selectedIndex = [_playerController selectedChapterIndex];
    for (size_t x = 0; x < count; x++) {
        const struct vlc_player_chapter *p_chapter = [_playerController chapterAtIndexForCurrentTitle:x];
        if (p_chapter == NULL) {
            break;
        }
        NSMenuItem *menuItem = [[NSMenuItem alloc] initWithTitle:toNSStr(p_chapter->name)
                                                          action:@selector(selectChapter:)
                                                   keyEquivalent:@""];
        [menuItem setTarget:self];
        [menuItem setTag:x];
        [menuItem setEnabled:YES];
        [menuItem setState: x == selectedIndex ? NSOnState : NSOffState];
        [_chapterMenu addItem:menuItem];
    }
    _chapter.enabled = count > 0 ? YES : NO;
}

- (void)selectTitle:(NSMenuItem *)sender
{
    _playerController.selectedTitleIndex = [sender tag];
}

- (void)selectChapter:(NSMenuItem *)sender
{
    _playerController.selectedChapterIndex = [sender tag];
}

#pragma mark - program handling
- (void)updateProgramMenu:(NSNotification *)notification
{
    [_programMenu removeAllItems];

    size_t count = [_playerController numberOfPrograms];
    for (size_t x = 0; x < count; x++) {
        VLCProgramMetaData *program = [_playerController programAtIndex:x];
        if (program == nil) {
            break;
        }
        NSMenuItem *menuItem = [[NSMenuItem alloc] initWithTitle:program.name
                                                          action:@selector(selectProgram:)
                                                   keyEquivalent:@""];
        [menuItem setTarget:self];
        [menuItem setRepresentedObject:program];
        [menuItem setEnabled:YES];
        [menuItem setState:program.selected ? NSOnState : NSOffState];
        [_programMenu addItem:menuItem];
    }
    _program.enabled = count > 0 ? YES : NO;
}

- (void)selectProgram:(NSMenuItem *)sender
{
    [_playerController selectProgram:[sender representedObject]];
}

#pragma mark - audio menu

- (void)refreshAudioDeviceList
{
    char **ids, **names;
    char *currentDevice;

    [_audioDeviceMenu removeAllItems];

    audio_output_t *p_aout = [_playerController mainAudioOutput];
    if (!p_aout)
        return;

    int numberOfAudioDevices = aout_DevicesList(p_aout, &ids, &names);
    if (numberOfAudioDevices < 0) {
        aout_Release(p_aout);
        return;
    }

    currentDevice = aout_DeviceGet(p_aout);
    NSMenuItem *_tmp;

    for (NSUInteger x = 0; x < (NSUInteger)numberOfAudioDevices; x++) {
        _tmp = [_audioDeviceMenu addItemWithTitle:toNSStr(names[x]) action:@selector(toggleAudioDevice:) keyEquivalent:@""];
        [_tmp setTarget:self];
        [_tmp setTag:[[NSString stringWithFormat:@"%s", ids[x]] intValue]];
    }
    aout_Release(p_aout);

    [[_audioDeviceMenu itemWithTag:[[NSString stringWithFormat:@"%s", currentDevice] intValue]] setState:NSOnState];

    free(currentDevice);

    for (NSUInteger x = 0; x < (NSUInteger)numberOfAudioDevices; x++) {
        free(ids[x]);
        free(names[x]);
    }
    free(ids);
    free(names);

    [_audioDeviceMenu setAutoenablesItems:YES];
    [_audioDevice setEnabled:YES];
}

- (void)toggleAudioDevice:(id)sender
{
    audio_output_t *p_aout = [_playerController mainAudioOutput];
    if (!p_aout)
        return;

    int returnValue = 0;

    if ([sender tag] > 0)
        returnValue = aout_DeviceSet(p_aout, [[NSString stringWithFormat:@"%li", [sender tag]] UTF8String]);
    else
        returnValue = aout_DeviceSet(p_aout, NULL);

    if (returnValue != 0)
        msg_Warn(getIntf(), "failed to set audio device %li", [sender tag]);

    aout_Release(p_aout);
    [self refreshAudioDeviceList];
}

#pragma mark - video menu

- (IBAction)toggleFullscreen:(id)sender
{
    [_playerController toggleFullscreen];
}

- (IBAction)resizeVideoWindow:(id)sender
{
    vout_thread_t *p_vout = [_playerController videoOutputThreadForKeyWindow];
    if (p_vout) {
        if (sender == _half_window)
            var_SetFloat(p_vout, "zoom", 0.5);
        else if (sender == _normal_window)
            var_SetFloat(p_vout, "zoom", 1.0);
        else if (sender == _double_window)
            var_SetFloat(p_vout, "zoom", 2.0);
        else
        {
            [[NSApp keyWindow] performZoom:sender];
        }
        vout_Release(p_vout);
    }
}

- (IBAction)floatOnTop:(id)sender
{
    vout_thread_t *p_vout = [_playerController videoOutputThreadForKeyWindow];
    if (p_vout) {
        var_ToggleBool(p_vout, "video-on-top");
        vout_Release(p_vout);
    }
}

- (IBAction)createVideoSnapshot:(id)sender
{
    [_playerController takeSnapshot];
}

- (void)_disablePostProcessing
{
    [_playerController enableVideoFilterWithName:@"postproc" state:NO];
}

- (void)_enablePostProcessing
{
    [_playerController enableVideoFilterWithName:@"postproc" state:YES];
}

- (void)togglePostProcessing:(id)sender
{
    NSInteger count = [_postprocessingMenu numberOfItems];
    for (NSUInteger x = 0; x < (NSUInteger)count; x++)
        [[_postprocessingMenu itemAtIndex:x] setState:NSOffState];

    if ([sender tag] == -1) {
        [self _disablePostProcessing];
        [sender setState:NSOnState];
    } else {
        [self _enablePostProcessing];
        [sender setState:NSOnState];

        [_playerController setVideoFilterProperty:@"postproc-q" forFilter:@"postproc" withValue:(vlc_value_t){ .i_int = [sender tag] }];
    }
}

- (void)toggleFullscreenDevice:(id)sender
{
    config_PutInt("macosx-vdev", [sender tag]);
    [self refreshVoutDeviceMenu: nil];
}

#pragma mark - Subtitles Menu

- (IBAction)addSubtitleFile:(id)sender
{
    NSInteger i_returnValue = 0;

    NSOpenPanel *openPanel = [NSOpenPanel openPanel];
    [openPanel setCanChooseFiles: YES];
    [openPanel setCanChooseDirectories: NO];
    [openPanel setAllowsMultipleSelection: YES];
    [openPanel setAllowedFileTypes:[NSString extensionsArrayFromVLCStyleString:EXTENSIONS_SUBTITLE]];

    NSURL *url = _playerController.URLOfCurrentMediaItem;
    url = [url URLByDeletingLastPathComponent];
    [openPanel setDirectoryURL: url];

    i_returnValue = [openPanel runModal];

    if (i_returnValue == NSModalResponseOK) {
        for (NSURL *url in [openPanel URLs]) {
            [_playerController addAssociatedMediaToCurrentFromURL:url
                                                       ofCategory:SPU_ES
                                                 shallSelectTrack:YES
                                                  shallDisplayOSD:YES
                                             shallVerifyExtension:NO];
        }
    }
}

- (IBAction)subtitleSize:(id)sender
{
    unsigned int scaleFactor = _subtitleSizeSlider.intValue;
    _playerController.subtitleTextScalingFactor = scaleFactor;
    [_subtitleSizeTextField setStringValue: [NSString stringWithFormat:@"%.2fx", scaleFactor / 100.]];
}

- (void)switchSubtitleOption:(id)sender
{
    NSMenuItem * const menuItem = (NSMenuItem *)sender;
    if (menuItem == nil) {
        return;
    }

    const NSInteger intValue = menuItem.tag;
    NSString * const representedObject = menuItem.representedObject;

    config_PutInt(representedObject.UTF8String, intValue);

    NSMenu * const menu = menuItem.menu;
    const NSUInteger count = (NSUInteger)menu.numberOfItems;
    for (NSUInteger x = 0; x < count; x++) {
        [menu itemAtIndex:x].state = NSOffState;
    }
    [menu itemWithTag:intValue].state = NSOnState;
}

- (IBAction)switchSubtitleBackgroundOpacity:(id)sender
{
    config_PutInt("freetype-background-opacity", [sender intValue]);
}

- (IBAction)telxTransparent:(id)sender
{
    _playerController.teletextTransparent = !_playerController.teletextTransparent;
}

- (IBAction)telxNavLink:(id)sender
{
    unsigned int page = 0;

    if ([[sender title] isEqualToString: _NS("Index")])
        page = VLC_PLAYER_TELETEXT_KEY_INDEX;
    else if ([[sender title] isEqualToString: _NS("Red")])
        page = VLC_PLAYER_TELETEXT_KEY_RED;
    else if ([[sender title] isEqualToString: _NS("Green")])
        page = VLC_PLAYER_TELETEXT_KEY_GREEN;
    else if ([[sender title] isEqualToString: _NS("Yellow")])
        page = VLC_PLAYER_TELETEXT_KEY_YELLOW;
    else if ([[sender title] isEqualToString: _NS("Blue")])
        page = VLC_PLAYER_TELETEXT_KEY_BLUE;

    _playerController.teletextPage = page;
}

#pragma mark - Panels

- (IBAction)intfOpenFile:(id)sender
{
    [[VLCMain.sharedInstance open] openFileWithAction:^(NSArray *files) {
        [self->_playQueueController addPlayQueueItems:files];
    }];
}

- (IBAction)intfOpenFileGeneric:(id)sender
{
    [[VLCMain.sharedInstance open] openFileGeneric];
}

- (IBAction)intfOpenDisc:(id)sender
{
    [[VLCMain.sharedInstance open] openDisc];
}

- (IBAction)intfOpenNet:(id)sender
{
    [[VLCMain.sharedInstance open] openNet];
}

- (IBAction)intfOpenCapture:(id)sender
{
    [[VLCMain.sharedInstance open] openCapture];
}

- (IBAction)intfConnectToServer:(id)sender
{
    VLCConnectToServerDialog * const dialog = [[VLCConnectToServerDialog alloc] init];
    [dialog show];
}

- (IBAction)savePlaylist:(id)sender
{
    static dispatch_once_t once;
    dispatch_once(&once, ^{
        [[NSBundle mainBundle] loadNibNamed:@"PlaylistAccessoryView" owner:self topLevelObjects:nil];
    });

    [_playlistSaveAccessoryText setStringValue: _NS("File Format:")];
    [_playlistSaveAccessoryPopup removeAllItems];

    NSArray *availableExportModules = _playQueueController.availablePlaylistExportModules;
    NSUInteger count = availableExportModules.count;
    NSMutableArray *allowedFileTypes = [NSMutableArray arrayWithCapacity:count];
    for (NSUInteger x = 0; x < count; x++) {
        VLCPlaylistExportModuleDescription *exportModule = availableExportModules[x];
        [_playlistSaveAccessoryPopup addItemWithTitle:exportModule.humanReadableName];
        [allowedFileTypes addObject:exportModule.fileExtension];
    }

    NSSavePanel *savePanel = [NSSavePanel savePanel];
    [savePanel setTitle: _NS("Save Playlist")];
    [savePanel setPrompt: _NS("Save")];
    [savePanel setAccessoryView: _playlistSaveAccessoryView];
    [savePanel setNameFieldStringValue: _NS("Untitled")];
    [savePanel setAllowedFileTypes:allowedFileTypes];
    [savePanel setCanSelectHiddenExtension:YES];

    if ([savePanel runModal] == NSModalResponseOK) {
        NSString *filename = [[savePanel URL] path];
        VLCPlaylistExportModuleDescription *exportModule = availableExportModules[[_playlistSaveAccessoryPopup indexOfSelectedItem]];

        if ([[filename pathExtension] caseInsensitiveCompare:exportModule.fileExtension] != NSOrderedSame) {
            filename = [filename stringByAppendingPathExtension:exportModule.fileExtension];
        }

        [_playQueueController exportPlaylistToPath:filename exportModule:exportModule];
    }
}

- (IBAction)savePlayQueueToLibrary:(id)sender
{
    // Check if there are items in the play queue
    if (_playQueueController.playQueueModel.numberOfPlayQueueItems == 0) {
        NSAlert * const alert = [[NSAlert alloc] init];
        alert.messageText = _NS("Play Queue is Empty");
        alert.informativeText = _NS("There are no items in the play queue to save.");
        alert.alertStyle = NSAlertStyleWarning;
        [alert runModal];
        return;
    }
    
    [VLCMain.sharedInstance.libraryController showCreatePlaylistDialogForPlayQueue];
}

- (IBAction)showConvertAndSave:(id)sender
{
    [[VLCMain.sharedInstance convertAndSaveWindow] showWindow:self];
}

- (IBAction)showVideoEffects:(id)sender
{
    [[VLCMain.sharedInstance videoEffectsPanel] toggleWindow:sender];
}

- (IBAction)showTrackSynchronization:(id)sender
{
    [[VLCMain.sharedInstance trackSyncPanel] toggleWindow:sender];
}

- (IBAction)showAudioEffects:(id)sender
{
    [[VLCMain.sharedInstance audioEffectsPanel] toggleWindow:sender];
}

- (IBAction)showBookmarks:(id)sender
{
    [[VLCMain.sharedInstance bookmarks] toggleWindow:sender];
}

- (IBAction)showPreferences:(id)sender
{
    VLCMain *mainInstance = VLCMain.sharedInstance;
    NSInteger i_level = [[mainInstance voutProvider] currentStatusWindowLevel];
    [[mainInstance simplePreferences] showSimplePrefsWithLevel:i_level];
}

- (IBAction)openAddonManager:(id)sender
{
    if (!_addonsController)
        _addonsController = [[VLCAddonsWindowController alloc] init];

    [_addonsController showWindow:self];
}

- (IBAction)showErrorsAndWarnings:(id)sender
{
    [[[VLCMain.sharedInstance coreDialogProvider] errorPanel] showWindow:self];
}

- (IBAction)showMessagesPanel:(id)showMessagesPanel
{
    [[VLCMain.sharedInstance debugMsgPanel] showWindow:self];
}

- (IBAction)showMainWindow:(id)sender
{
    [VLCMain.sharedInstance.libraryWindow makeKeyAndOrderFront:sender];
}

- (IBAction)showPlayQueue:(id)sender
{
    [VLCMain.sharedInstance.libraryWindowController.window makeKeyAndOrderFront:sender];
    [VLCMain.sharedInstance.libraryWindow.splitViewController toggleMultifunctionSidebar:self];
}

#pragma mark - Help and Docs

- (IBAction)showAbout:(id)sender
{
    if (!_aboutWindowController)
        _aboutWindowController = [[VLCAboutWindowController alloc] init];

    [_aboutWindowController showAbout];
}

- (IBAction)showLicense:(id)sender
{
    if (!_aboutWindowController)
        _aboutWindowController = [[VLCAboutWindowController alloc] init];

    [_aboutWindowController showGPL];
}

- (IBAction)showHelp:(id)sender
{
    if (!_helpWindowController)
        _helpWindowController = [[VLCHelpWindowController alloc] init];

    [_helpWindowController showHelp];
}

- (IBAction)openDocumentation:(id)sender
{
    NSURL *url = [NSURL URLWithString: @"https://www.videolan.org/doc/"];

    [NSWorkspace.sharedWorkspace openURL: url];
}

- (IBAction)openWebsite:(id)sender
{
    NSURL *url = [NSURL URLWithString: @"https://www.videolan.org/"];

    [NSWorkspace.sharedWorkspace openURL: url];
}

- (IBAction)openForum:(id)sender
{
    NSURL *url = [NSURL URLWithString: @"https://forum.videolan.org/"];

    [NSWorkspace.sharedWorkspace openURL: url];
}

- (IBAction)openDonate:(id)sender
{
    NSURL *url = [NSURL URLWithString: @"https://www.videolan.org/contribute.html#paypal"];

    [NSWorkspace.sharedWorkspace openURL: url];
}

- (IBAction)showDetachedAudioWindow:(id)sender
{
    [VLCMain.sharedInstance.detachedAudioWindow makeKeyAndOrderFront:self];
}

- (IBAction)showInformationPanel:(id)sender
{
    if (!_infoWindowController) {
        _infoWindowController = [[VLCInformationWindowController alloc] init];
        _infoWindowController.mainMenuInstance = YES;
    }

    _infoWindowController.representedInputItems = @[_playQueueController.currentlyPlayingInputItem];
    [_infoWindowController toggleWindow:sender];
}

#pragma mark - playback state

- (void)playbackStateChanged:(NSNotification *)aNotification
{
    [self updateVideoSubmenuEnablement];
    [self updateAudioSubmenuEnablement];

    switch (_playerController.playerState) {
        case VLC_PLAYER_STATE_PLAYING:
            [self setPause];
            break;
        default:
            [self setPlay];
            break;
    }
}

- (void)playModeChanged:(NSNotification *)aNotification
{
    enum vlc_playlist_playback_repeat repeatState = _playQueueController.playbackRepeat;
    switch (repeatState) {
        case VLC_PLAYLIST_PLAYBACK_REPEAT_ALL:
            [self setRepeatAll];
            break;

        case VLC_PLAYLIST_PLAYBACK_REPEAT_CURRENT:
            [self setRepeatOne];
            break;

        default:
            [self setRepeatOff];
            break;
    }
}

- (void)playOrderChanged:(NSNotification *)aNotification
{
    [_random setState:_playQueueController.playbackOrder == VLC_PLAYLIST_PLAYBACK_ORDER_RANDOM];
}

- (void)setPlay
{
    [_play setTitle: _NS("Play")];
    [_dockMenuplay setTitle: _NS("Play")];
    [_voutMenuplay setTitle: _NS("Play")];
    [_play vlc_setActionImageWithSystemSymbolName:@"play.fill"];
    [_voutMenuplay vlc_setActionImageWithSystemSymbolName:@"play.fill"];
}

- (void)setPause
{
    [_play setTitle: _NS("Pause")];
    [_dockMenuplay setTitle: _NS("Pause")];
    [_voutMenuplay setTitle: _NS("Pause")];
    [_play vlc_setActionImageWithSystemSymbolName:@"pause.fill"];
    [_voutMenuplay vlc_setActionImageWithSystemSymbolName:@"pause.fill"];
}

- (void)setRepeatOne
{
    [_repeat setState: NSOnState];
    [_repeat setTitle: _NS("Repeat One")];
}

- (void)setRepeatAll
{
    [_repeat setState: NSOnState];
    [_repeat setTitle: _NS("Repeat All")];
}

- (void)setRepeatOff
{
    [_repeat setState: NSOffState];
    [_repeat setTitle: _NS("Repeat")];
}

#pragma mark - Dynamic menu creation and validation

- (void)setupVarMenuItem:(NSMenuItem *)menuItem
                  target:(vlc_object_t *)p_object
              objectType:(VLCObjectType)objectType
                     var:(const char *)psz_variable
                selector:(SEL)pf_callback
{
    vlc_value_t val;
    char *text;
    int i_type = var_Type(p_object, psz_variable);

    switch(i_type & VLC_VAR_TYPE) {
        case VLC_VAR_VOID:
        case VLC_VAR_BOOL:
        case VLC_VAR_STRING:
        case VLC_VAR_INTEGER:
            break;
        default:
            /* Variable doesn't exist or isn't handled */
            msg_Warn(p_object, "variable %s doesn't exist or isn't handled", psz_variable);
            return;
    }

    /* Get the descriptive name of the variable */
    var_Change(p_object, psz_variable, VLC_VAR_GETTEXT, &text);
    [menuItem setTitle: NSTR(text ? text : psz_variable)];

    if (i_type & VLC_VAR_HASCHOICE) {
        NSMenu *menu = [menuItem submenu];

        [self setupVarMenu:menu
               forMenuItem:menuItem
                    target:p_object
                objectType:objectType
                       var:psz_variable
                  selector:pf_callback];

        free(text);
        return;
    }

    if (var_Get(p_object, psz_variable, &val) < 0) {
        return;
    }

    VLCAutoGeneratedMenuContent *data;
    switch(i_type & VLC_VAR_TYPE) {
        case VLC_VAR_VOID:
            data = [[VLCAutoGeneratedMenuContent alloc] initWithVariableName:psz_variable
                                                                    ofObject:p_object
                                                              withObjectType:objectType
                                                                    andValue:val
                                                              ofVariableType:i_type];
            [menuItem setRepresentedObject:data];
            break;

        case VLC_VAR_BOOL:
            data = [[VLCAutoGeneratedMenuContent alloc] initWithVariableName:psz_variable
                                                                    ofObject:p_object
                                                              withObjectType:objectType
                                                                    andValue:val
                                                              ofVariableType:i_type];
            [menuItem setRepresentedObject:data];
            if (!(i_type & VLC_VAR_ISCOMMAND))
                [menuItem setState:val.b_bool ? NSOnState : NSOffState];
            break;

        default:
            break;
    }

    if ((i_type & VLC_VAR_TYPE) == VLC_VAR_STRING)
        free(val.psz_string);
    free(text);
}

- (void)setupVarMenu:(NSMenu *)menu
         forMenuItem:(NSMenuItem *)parent
              target:(vlc_object_t *)p_object
          objectType:(VLCObjectType)objectType
                 var:(const char *)psz_variable
            selector:(SEL)pf_callback
{
    vlc_value_t val;
    vlc_value_t *val_list;
    char **text_list;
    size_t count, i;
    int i_type;

    /* remove previous items */
    [menu removeAllItems];

    /* we disable everything here, and enable it again when needed, below */
    [parent setEnabled:NO];

    /* Aspect Ratio */
    if ([[parent title] isEqualToString:_NS("Aspect ratio")] == YES) {
        NSMenuItem *lmi_tmp2;
        lmi_tmp2 = [menu addItemWithTitle:_NS("Lock Aspect Ratio")
                                   action:@selector(lockVideosAspectRatio:)
                            keyEquivalent:@""];
        [lmi_tmp2 setTarget: self];
        [lmi_tmp2 setEnabled: YES];
        [lmi_tmp2 setState: [_playerController aspectRatioIsLocked]];
        [parent setEnabled: YES];
        [menu addItem: [NSMenuItem separatorItem]];
    }

    /* Check the type of the object variable */
    i_type = var_Type(p_object, psz_variable);

    /* Make sure we want to display the variable */
    if (i_type & VLC_VAR_HASCHOICE) {
        size_t count;

        var_Change(p_object, psz_variable, VLC_VAR_CHOICESCOUNT, &count);
        if (count <= 1)
            return;
    }
    else
        return;

    switch(i_type & VLC_VAR_TYPE) {
        case VLC_VAR_VOID:
        case VLC_VAR_BOOL:
        case VLC_VAR_STRING:
        case VLC_VAR_INTEGER:
            break;
        default:
            /* Variable doesn't exist or isn't handled */
            return;
    }

    if (var_Get(p_object, psz_variable, &val) < 0) {
        return;
    }

    if (var_Change(p_object, psz_variable, VLC_VAR_GETCHOICES,
                   &count, &val_list, &text_list) < 0) {
        if ((i_type & VLC_VAR_TYPE) == VLC_VAR_STRING)
            free(val.psz_string);
        return;
    }

    /* make (un)sensitive */
    [parent setEnabled:(count > 1)];

    for (i = 0; i < count; i++) {
        NSMenuItem *lmi;
        NSString *title = @"";
        VLCAutoGeneratedMenuContent *data;

        switch(i_type & VLC_VAR_TYPE) {
            case VLC_VAR_STRING:

                title = NSTR(text_list[i] ? text_list[i] : val_list[i].psz_string);

                lmi = [menu addItemWithTitle:title action:pf_callback keyEquivalent:@""];
                data = [[VLCAutoGeneratedMenuContent alloc] initWithVariableName:psz_variable
                                                                        ofObject:p_object
                                                                  withObjectType:objectType
                                                                        andValue:val_list[i]
                                                                  ofVariableType:i_type];
                [lmi setRepresentedObject:data];
                [lmi setTarget:self];

                if (!strcmp(val.psz_string, val_list[i].psz_string) && !(i_type & VLC_VAR_ISCOMMAND))
                    [lmi setState:NSOnState];

                free(text_list[i]);
                free(val_list[i].psz_string);
                break;

            case VLC_VAR_INTEGER:

                title = text_list[i] ?
                NSTR(text_list[i]) : [NSString stringWithFormat:@"%"PRId64, val_list[i].i_int];

                lmi = [menu addItemWithTitle: title action: pf_callback keyEquivalent: @""];
                data = [[VLCAutoGeneratedMenuContent alloc] initWithVariableName:psz_variable
                                                                        ofObject:p_object
                                                                  withObjectType:objectType
                                                                        andValue:val_list[i]
                                                                  ofVariableType:i_type];
                [lmi setRepresentedObject:data];
                [lmi setTarget:self];

                if (val_list[i].i_int == val.i_int && !(i_type & VLC_VAR_ISCOMMAND))
                    [lmi setState:NSOnState];

                free(text_list[i]);
                break;

            default:
                break;
        }
    }

    /* clean up everything */
    if ((i_type & VLC_VAR_TYPE) == VLC_VAR_STRING) free(val.psz_string);
    free(text_list);
    free(val_list);
}

- (void)toggleVar:(id)sender
{
    NSMenuItem *mi = (NSMenuItem *)sender;
    VLCAutoGeneratedMenuContent *data = [mi representedObject];
    [NSThread detachNewThreadSelector:@selector(toggleVarThread:)
                             toTarget:self
                           withObject:data];

    return;
}

- (void)toggleVarThread:(id)data
{
    @autoreleasepool {
        vlc_object_t *p_object;

        assert([data isKindOfClass:[VLCAutoGeneratedMenuContent class]]);
        VLCAutoGeneratedMenuContent *menuContent = (VLCAutoGeneratedMenuContent *)data;

        p_object = [menuContent vlcObject];
        var_Set(p_object, [menuContent variableName], [menuContent variableValue]);

        if ([menuContent objectType] == VLCObjectTypeAout) {
            dispatch_async(dispatch_get_main_queue(), ^{
                [self rebuildAoutMenu];
            });
        }
    }
}

#pragma mark - crop and AR customization

- (void)appendCustomizationItem:(NSMenuItem *)menuItem
{
    NSMenu *submenu = menuItem.submenu;
    NSMenuItem *customizationItem = [[NSMenuItem alloc] initWithTitle:_NS("Custom")
                                                               action:menuItem == _aspect_ratio ? @selector(performCustomAspectRatio:) : @selector(performCustomCrop:)
                                                        keyEquivalent:@""];
    [customizationItem setTarget:self];
    [submenu addItem:[NSMenuItem separatorItem]];
    [submenu addItem:customizationItem];
}

- (void)performCustomCropOrAspectRatioActionWithVariable:(const char *)variable andl10nString:(NSString *)l10nString
{
    if (!_customARController) {
        _customARController = [[VLCCustomCropArWindowController alloc] init];
    }
    _customARController.title = l10nString;
    [_customARController runModalForWindow:[NSApp mainWindow]
                         completionHandler:^(NSInteger returnCode, NSString * _Nonnull geometry) {
                             if (returnCode != NSModalResponseOK) {
                                 return;
                             }

                             vout_thread_t *p_vout = [self->_playerController videoOutputThreadForKeyWindow];
                             if (p_vout) {
                                 var_SetString(p_vout, variable, [geometry UTF8String]);
                                 vout_Release(p_vout);
                             }
                         }];
}

- (void)performCustomAspectRatio:(id)sender
{
    [self performCustomCropOrAspectRatioActionWithVariable:"aspect-ratio" andl10nString:_NS("Aspect Ratio")];
}

- (void)performCustomCrop:(id)sender
{
    [self performCustomCropOrAspectRatioActionWithVariable:"crop" andl10nString:_NS("Crop")];
}

#pragma mark - menu delegation

- (void)menuWillOpen:(NSMenu *)menu
{
    [_rendererMenuController startRendererDiscoveries];
    [_rendererMenuController updateRendererMenuItemEnablement];

    if (menu == self.fileMenu) {
        [self updateRecentMenuEnablement];
    }

    if (menu == self.audioMenu) {
        [self updateAudioSubmenuEnablement];
    }

    if (menu == self.videoMenu) {
        [self updateVideoSubmenuEnablement];
    }

    if (@available(macOS 10.16, *)) {

        const int menuItemOffset = 14;
        const int menuItemOffsetWithActiveState = 24;

        if (menu == _controlsMenu) {
            BOOL controlsMenuHasActiveState = NO;
            for (NSMenuItem * const viewMenuItem in menu.itemArray) {
                if (viewMenuItem.state == NSControlStateValueOn) {
                    controlsMenuHasActiveState = YES;
                }
            }

            if (controlsMenuHasActiveState) {
                _rate_view_offset_constraint.constant = menuItemOffsetWithActiveState;
            } else {
                _rate_view_offset_constraint.constant = menuItemOffset;
            }
        }

        if (menu == _subtitlesMenu) {
            [self updateSubtitlesMenu:nil];
            _subtitle_bgopacity_view_offset_constraint.constant = menuItemOffset;
            _subtitleSizeViewOffsetConstraint.constant = menuItemOffset;
        }
    }
}

- (BOOL)validateUserInterfaceItem:(id<NSValidatedUserInterfaceItem>)item
{
    NSMenuItem * const mi = (NSMenuItem *)item;

    if (mi == nil) {
        return YES;
    } else if (mi == self.savePlayqueueToLibrary) {
        return VLCMain.sharedInstance.libraryController.libraryModel != nil &&
               _playQueueController.playQueueModel.numberOfPlayQueueItems > 0;
    } else if (mi == self.bookmarks || mi == self.libraryPlayQueueMode) {
        return VLCMain.sharedInstance.libraryController.libraryModel != nil;
    } else if (mi == self.play) {
        return _playerController.playerState == VLC_PLAYER_STATE_PLAYING
            ? _playerController.currentMedia != nil && _playerController.pausable
            : _playQueueController.playQueueModel.numberOfPlayQueueItems > 0;
    } else if (mi == self.stop ||
               mi == self.voutMenustop ||
               mi == self.dockMenustop ||
               mi == self.visual ||
               mi == self.channels) {
        return _playerController.currentMedia &&
               _playerController.playerState != VLC_PLAYER_STATE_STOPPED;
    } else if (mi == self.previous || mi == self.voutMenuprev || mi == self.dockMenuprevious) {
        return _playQueueController.hasPreviousPlayQueueItem;
    } else if (mi == self.next || mi == self.voutMenunext || mi == self.dockMenunext) {
        return _playQueueController.hasNextPlayQueueItem;
    } else if (mi == self.record || mi == self.voutMenuRecord) {
        return _playerController.currentMedia != nil && _playerController.recordable;
    } else if (mi == self.random) {
        const enum vlc_playlist_playback_order playbackOrder = _playQueueController.playbackOrder;
        mi.state = playbackOrder == VLC_PLAYLIST_PLAYBACK_ORDER_RANDOM ? NSOnState : NSOffState;
    } else if (mi == self.quitAfterPB) {
        const BOOL state = _playQueueController.actionAfterStop == VLC_PLAYLIST_MEDIA_STOPPED_EXIT;
        mi.state = state ? NSOnState : NSOffState;
    } else if (mi == self.fwd || mi == self.bwd || mi == self.jumpToTime) {
        return _playerController.currentMedia != nil && _playerController.seekable;
    } else if (mi == self.lyrics) {
        mi.state = _playerController.showLyrics ? NSOnState : NSOffState;
        return _playerController.lyricsAvailable;
    } else if (mi == self.mute || mi == self.dockMenumute || mi == self.voutMenumute) {
        mi.state = _playerController.mute ? NSOnState : NSOffState;
        [self refreshAudioDeviceList];
    } else if (mi == self.half_window               ||
               mi == self.normal_window             ||
               mi == self.double_window             ||
               mi == self.fittoscreen               ||
               mi == self.snapshot                  ||
               mi == self.voutMenusnapshot          ||
               mi == self.deinterlace               ||
               mi == self.deinterlace_mode          ||
               mi == self.screen                    ||
               mi == self.aspect_ratio              ||
               mi == self.crop                      ||
               mi == self.postprocessing            ||
               mi == self.fullscreenItem            ||
               mi == self.voutMenufullscreen        ||
               mi == self.floatontop) {
        vout_thread_t * const p_vout = _playerController.videoOutputThreadForKeyWindow;
        if (p_vout != NULL) {
            if (mi == self.floatontop) {
                mi.state = var_GetBool(p_vout, "video-on-top") ? NSOnState : NSOffState;
                if (_playerController.fullscreen) {
                    vout_Release(p_vout);
                    return NO;
                }
            } else if (mi == self.fullscreenItem || mi == self.voutMenufullscreen) {
                mi.state = _playerController.fullscreen ? NSOnState : NSOffState;
            }
            vout_Release(p_vout);
        }
        return p_vout != NULL &&
               _playerController.currentMedia != nil &&
               _playerController.activeVideoPlayback;
    } else if (mi == self.rate) {
        return _playerController.currentMedia && _playerController.rateChangable;
    } else if (mi == self.info) {
        return _playerController.currentMedia != nil;
    } else if (mi == self.openSubtitleFile          ||
               mi == self.voutMenuOpenSubtitleFile  ||
               mi == self.subtitleSize) {
        return _playerController.currentMedia != nil && _playerController.activeVideoPlayback;
    } else if (mi == self.teletext) {
        return _playerController.currentMedia != nil && _playerController.teletextMenuAvailable;
    } else if (mi == self.voutMenuAudiotrack) {
        return _playerController.audioTracks.count > 0;
    } else if (mi == self.videotrack || mi == self.voutMenuVideotrack) {
        return _playerController.videoTracks.count > 0;
    } else if (mi == self.voutMenuSubtitlestrack) {
        return _playerController.subtitleTracks.count > 0;
    } else if (mi == self.libraryPlayQueueMode ||
               mi == self.bookmarks ||
               mi == self.savePlayqueueToLibrary) {
        return VLCMain.sharedInstance.libraryController.libraryModel != nil;
    } else {
        NSMenuItem * const parent = mi.parentItem;
        if (parent == self.subtitle_textcolor || mi == self.subtitle_textcolor ||
            parent == self.subtitle_bgcolor || mi == self.subtitle_bgcolor     ||
            parent == self.subtitle_bgopacity || mi == self.subtitle_bgopacity ||
            parent == self.subtitle_outlinethickness || mi == self.subtitle_outlinethickness) {

            return [self validateUserInterfaceItem:self.openSubtitleFile];
        } else if (parent == self.teletext || mi == self.teletext) {
            return _playerController.teletextMenuAvailable;
        }
    }

    return YES;
}

@end

/*****************************************************************************
 *VLCAutoGeneratedMenuContent implementation
 *****************************************************************************
 *Object connected to a playlistitem which remembers the data belonging to
 *the variable of the autogenerated menu
 *****************************************************************************/

@implementation VLCAutoGeneratedMenuContent

- (instancetype)initWithVariableName:(const char *)name
                            ofObject:(vlc_object_t *)object
                      withObjectType:(VLCObjectType)objectType
                            andValue:(vlc_value_t)value
                      ofVariableType:(int)type
{
    self = [super init];

    if (self != nil) {
        switch (objectType) {
            case VLCObjectTypeAout:
                aout_Hold((audio_output_t *)object);
                break;
            case VLCObjectTypeVout:
                vout_Hold((vout_thread_t *)object);
                break;

            default:
                // No need to retain the interface because it will always be there
                break;
        }
        _vlcObject = object;
        _objectType = objectType;
        _variableName = strdup(name);
        _variableType = type;
        _variableValue = value;
        if ((type & VLC_VAR_TYPE) == VLC_VAR_STRING) {
            _variableValue.psz_string = strdup(value.psz_string);
        }
    }

    return(self);
}

- (void)dealloc
{
    if (_vlcObject) {
        switch (_objectType) {
            case VLCObjectTypeAout:
                aout_Release((audio_output_t *)_vlcObject);
                break;
            case VLCObjectTypeVout:
                vout_Release((vout_thread_t *)_vlcObject);
                break;

            default:
                // the interface will be released by the core shortly
                break;
        }
    }
    if ((_variableType & VLC_VAR_TYPE) == VLC_VAR_STRING) {
        free(_variableValue.psz_string);
    }
    free(_variableName);
}

@end

@implementation NSMenuItem (KeyEquivalentAddition)

- (void)matchKeyEquivalentsOfMenuItem:(NSMenuItem *)menuItem
{
    self.keyEquivalent = menuItem.keyEquivalent;
    self.keyEquivalentModifierMask = menuItem.keyEquivalentModifierMask;
}

@end