GUIMainControl.java

Go to the documentation of this file.

/*
 * Gridarta MMORPG map editor for Crossfire, Daimonin and similar games.
 * Copyright (C) 2000-2015 The Gridarta Developers.
 *
 * 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.
 */
 
package net.sf.gridarta.maincontrol;
 
import java.awt.BorderLayout;
import java.awt.Container;
import java.io.File;
import java.io.IOException;
import java.util.List;
import java.util.MissingResourceException;
import java.util.ResourceBundle;
import java.util.prefs.Preferences;
import javax.swing.Action;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import net.sf.gridarta.MainControl;
import net.sf.gridarta.action.AddBookmarkAction;
import net.sf.gridarta.action.AddToSelectionAction;
import net.sf.gridarta.action.ArchAttributesAction;
import net.sf.gridarta.action.BrowseArchetypesAction;
import net.sf.gridarta.action.CleanCompletelyBlockedSquaresAction;
import net.sf.gridarta.action.CloseAllMapsAction;
import net.sf.gridarta.action.CollectArchesAction;
import net.sf.gridarta.action.CollectSpellsAction;
import net.sf.gridarta.action.ControlClientAction;
import net.sf.gridarta.action.ControlServerAction;
import net.sf.gridarta.action.DeleteArchAction;
import net.sf.gridarta.action.DisplayArchetypeNamesAction;
import net.sf.gridarta.action.DisplayGameObjectNamesAction;
import net.sf.gridarta.action.DisplayIconsOnlyAction;
import net.sf.gridarta.action.EditScriptAction;
import net.sf.gridarta.action.ExitAction;
import net.sf.gridarta.action.FindArchetypesAction;
import net.sf.gridarta.action.GcAction;
import net.sf.gridarta.action.GoLocationAction;
import net.sf.gridarta.action.GrowSelectionAction;
import net.sf.gridarta.action.InsertArchAction;
import net.sf.gridarta.action.LightVisibleAction;
import net.sf.gridarta.action.ManageBookmarksAction;
import net.sf.gridarta.action.MoveSquareBottomAction;
import net.sf.gridarta.action.MoveSquareDownAction;
import net.sf.gridarta.action.MoveSquareEnvAction;
import net.sf.gridarta.action.MoveSquareInvAction;
import net.sf.gridarta.action.MoveSquareNextAction;
import net.sf.gridarta.action.MoveSquarePrevAction;
import net.sf.gridarta.action.MoveSquareTopAction;
import net.sf.gridarta.action.MoveSquareUpAction;
import net.sf.gridarta.action.NewMapAction;
import net.sf.gridarta.action.OpenFileAction;
import net.sf.gridarta.action.OptionsAction;
import net.sf.gridarta.action.ReleaseDragAction;
import net.sf.gridarta.action.ReloadFacesAction;
import net.sf.gridarta.action.SaveAllMapsAction;
import net.sf.gridarta.action.SelectArchAboveAction;
import net.sf.gridarta.action.SelectArchBelowAction;
import net.sf.gridarta.action.SelectSquareAction;
import net.sf.gridarta.action.ShortcutsAction;
import net.sf.gridarta.action.ShowHelpAction;
import net.sf.gridarta.action.ShrinkSelectionAction;
import net.sf.gridarta.action.StartStopDragAction;
import net.sf.gridarta.action.SubFromSelectionAction;
import net.sf.gridarta.action.TipOfTheDayAction;
import net.sf.gridarta.action.ValidateMapAction;
import net.sf.gridarta.action.ViewTreasurelistsAction;
import net.sf.gridarta.action.ZoomAction;
import net.sf.gridarta.action.exportmap.ExportMapAsImageAction;
import net.sf.gridarta.actions.ExitConnectorActions;
import net.sf.gridarta.gui.autovalidator.AutoValidator;
import net.sf.gridarta.gui.copybuffer.CopyBuffer;
import net.sf.gridarta.gui.delayedmapmodel.DelayedMapModelListenerManager;
import net.sf.gridarta.gui.dialog.find.FindDialogManager;
import net.sf.gridarta.gui.dialog.gameobjectattributes.GameObjectAttributesDialogFactory;
import net.sf.gridarta.gui.dialog.goexit.GoExitDialogManager;
import net.sf.gridarta.gui.dialog.gomap.GoMapDialogManager;
import net.sf.gridarta.gui.dialog.mapproperties.MapPropertiesDialogFactory;
import net.sf.gridarta.gui.dialog.newmap.NewMapDialogFactory;
import net.sf.gridarta.gui.dialog.plugin.PluginController;
import net.sf.gridarta.gui.dialog.plugin.PluginManagerFactory;
import net.sf.gridarta.gui.dialog.plugin.parameter.PluginParameterViewFactory;
import net.sf.gridarta.gui.dialog.replace.ReplaceDialogManager;
import net.sf.gridarta.gui.dialog.shortcuts.ShortcutsManager;
import net.sf.gridarta.gui.exitconnector.ExitConnectorController;
import net.sf.gridarta.gui.filter.DefaultFilterControl;
import net.sf.gridarta.gui.filter.FilterControl;
import net.sf.gridarta.gui.mainwindow.GameObjectTab;
import net.sf.gridarta.gui.mainwindow.GameObjectTextEditorTab;
import net.sf.gridarta.gui.mainwindow.WarningsTab;
import net.sf.gridarta.gui.map.MapFileActions;
import net.sf.gridarta.gui.map.mapactions.EnterMap;
import net.sf.gridarta.gui.map.mapactions.MapActions;
import net.sf.gridarta.gui.map.mapview.MapViewFactory;
import net.sf.gridarta.gui.map.mapview.MapViewManager;
import net.sf.gridarta.gui.map.mapview.MapViewsManager;
import net.sf.gridarta.gui.map.renderer.ImageCreator;
import net.sf.gridarta.gui.map.renderer.ImageCreator2;
import net.sf.gridarta.gui.map.renderer.RendererFactory;
import net.sf.gridarta.gui.map.viewaction.ViewActions;
import net.sf.gridarta.gui.mapcursor.MapCursorActions;
import net.sf.gridarta.gui.mapdesktop.MapDesktop;
import net.sf.gridarta.gui.mapdesktop.WindowMenuManager;
import net.sf.gridarta.gui.mapfiles.Loader;
import net.sf.gridarta.gui.mapfiles.MapFolderTree;
import net.sf.gridarta.gui.mapfiles.MapFolderTreeActions;
import net.sf.gridarta.gui.mapimagecache.MapImageCache;
import net.sf.gridarta.gui.mapmenu.BookmarksMapMenuPreferences;
import net.sf.gridarta.gui.mapmenu.MapMenu;
import net.sf.gridarta.gui.mapmenu.MapMenuManager;
import net.sf.gridarta.gui.mapmenu.MapMenuPreferences;
import net.sf.gridarta.gui.mapmenu.RecentMapMenuPreferences;
import net.sf.gridarta.gui.mapuserlistener.MapKeyListener;
import net.sf.gridarta.gui.mapuserlistener.MapUserListenerManager;
import net.sf.gridarta.gui.misc.About;
import net.sf.gridarta.gui.misc.DefaultFileControl;
import net.sf.gridarta.gui.misc.MainToolbar;
import net.sf.gridarta.gui.misc.MainView;
import net.sf.gridarta.gui.misc.MainViewActions;
import net.sf.gridarta.gui.misc.RecentManager;
import net.sf.gridarta.gui.misc.StatusBar;
import net.sf.gridarta.gui.panel.archetypechooser.ArchetypeChooserControl;
import net.sf.gridarta.gui.panel.archetypechooser.ArchetypeChooserView;
import net.sf.gridarta.gui.panel.archetypechooser.ArchetypeIconCellRenderer;
import net.sf.gridarta.gui.panel.archetypechooser.ArchetypeNameCellRenderer;
import net.sf.gridarta.gui.panel.archetypechooser.DisplayNameCellRenderer;
import net.sf.gridarta.gui.panel.connectionview.ConnectionControl;
import net.sf.gridarta.gui.panel.connectionview.Control;
import net.sf.gridarta.gui.panel.connectionview.LockedItemsControl;
import net.sf.gridarta.gui.panel.connectionview.MonsterControl;
import net.sf.gridarta.gui.panel.gameobjectattributes.ArchTab;
import net.sf.gridarta.gui.panel.gameobjectattributes.ErrorListView;
import net.sf.gridarta.gui.panel.gameobjectattributes.EventsTab;
import net.sf.gridarta.gui.panel.gameobjectattributes.FaceTab;
import net.sf.gridarta.gui.panel.gameobjectattributes.GameObjectAttributesControl;
import net.sf.gridarta.gui.panel.gameobjectattributes.GameObjectAttributesModel;
import net.sf.gridarta.gui.panel.gameobjectattributes.MsgTextTab;
import net.sf.gridarta.gui.panel.gameobjectattributes.TextEditorTab;
import net.sf.gridarta.gui.panel.gameobjecttexteditor.GameObjectTextEditor;
import net.sf.gridarta.gui.panel.objectchooser.DefaultObjectChooser;
import net.sf.gridarta.gui.panel.pickmapchooser.PickmapChooserControl;
import net.sf.gridarta.gui.panel.pickmapchooser.PickmapChooserModel;
import net.sf.gridarta.gui.panel.pickmapchooser.PickmapChooserView;
import net.sf.gridarta.gui.panel.selectedsquare.SelectedSquareModel;
import net.sf.gridarta.gui.panel.selectedsquare.SelectedSquareView;
import net.sf.gridarta.gui.panel.tools.ToolPalette;
import net.sf.gridarta.gui.scripts.ImportPluginAction;
import net.sf.gridarta.gui.scripts.SavePluginsAction;
import net.sf.gridarta.gui.scripts.ScriptArchDataUtils;
import net.sf.gridarta.gui.scripts.ScriptArchEditor;
import net.sf.gridarta.gui.scripts.ScriptedEventEditor;
import net.sf.gridarta.gui.spells.SpellsUtils;
import net.sf.gridarta.gui.treasurelist.CFTreasureListTree;
import net.sf.gridarta.gui.undo.UndoControl;
import net.sf.gridarta.gui.utils.MenuUtils;
import net.sf.gridarta.gui.utils.borderpanel.Location;
import net.sf.gridarta.gui.utils.tabbedpanel.Tab;
import net.sf.gridarta.mainactions.DefaultExiter;
import net.sf.gridarta.mainactions.MainActions;
import net.sf.gridarta.model.anim.AnimationValidator;
import net.sf.gridarta.model.archetype.Archetype;
import net.sf.gridarta.model.archetypechooser.DisplayMode;
import net.sf.gridarta.model.archetypeset.ArchetypeValidator;
import net.sf.gridarta.model.configsource.ConfigSourceFactory;
import net.sf.gridarta.model.errorview.ErrorView;
import net.sf.gridarta.model.errorview.ErrorViewCollector;
import net.sf.gridarta.model.exitconnector.DefaultExitConnectorModel;
import net.sf.gridarta.model.exitconnector.ExitConnectorModel;
import net.sf.gridarta.model.exitconnector.ExitMatcher;
import net.sf.gridarta.model.filter.NamedFilter;
import net.sf.gridarta.model.gameobject.GameObject;
import net.sf.gridarta.model.maparchobject.MapArchObject;
import net.sf.gridarta.model.mapmodel.InsertionModeSet;
import net.sf.gridarta.model.mapviewsettings.DefaultMapViewSettings;
import net.sf.gridarta.model.mapviewsettings.MapViewSettings;
import net.sf.gridarta.model.match.GameObjectMatcher;
import net.sf.gridarta.model.match.TypeNrsGameObjectMatcher;
import net.sf.gridarta.model.pickmapsettings.DefaultPickmapSettings;
import net.sf.gridarta.model.pickmapsettings.PickmapSettings;
import net.sf.gridarta.model.scripts.ScriptArchUtils;
import net.sf.gridarta.model.scripts.ScriptedEventFactory;
import net.sf.gridarta.model.settings.DefaultVolatileSettings;
import net.sf.gridarta.model.settings.EditorSettings;
import net.sf.gridarta.model.settings.VolatileSettings;
import net.sf.gridarta.project.ProjectModel;
import net.sf.gridarta.textedit.scripteditor.MenuEntries;
import net.sf.gridarta.textedit.scripteditor.ScriptEditControl;
import net.sf.gridarta.textedit.textarea.TextAreaDefaults;
import net.sf.gridarta.updater.UpdaterManager;
import net.sf.gridarta.utils.ActionBuilderUtils;
import net.sf.gridarta.utils.AppPreferencesModel;
import net.sf.gridarta.utils.EditorAction;
import net.sf.gridarta.utils.Exiter;
import net.sf.gridarta.utils.GuiFileFilters;
import net.sf.gridarta.utils.ResourceIcons;
import net.sf.japi.swing.action.ActionBuilder;
import net.sf.japi.swing.action.ActionBuilderFactory;
import net.sf.japi.swing.tod.TipOfTheDayManager;
import net.sf.japi.util.ThrowableHandler;
import org.apache.log4j.Category;
import org.apache.log4j.Logger;
import org.jetbrains.annotations.NotNull;
 
public class GUIMainControl<G extends GameObject<G, A, R>, A extends MapArchObject<A>, R extends Archetype<G, A, R>> implements ThrowableHandler<Throwable> {
 
    @NotNull
    private static final ActionBuilder ACTION_BUILDER = ActionBuilderFactory.getInstance().getActionBuilder("net.sf.gridarta");
 
    @NotNull
    private static final Category LOG = Logger.getLogger(GUIMainControl.class);
 
    @NotNull
    private static final Preferences PREFERENCES = Preferences.userNodeForPackage(MainControl.class);
 
    @NotNull
    private final ProjectModel<G, A, R> projectModel;
 
    @NotNull
    private final JFrame mainViewFrame;
 
    @NotNull
    private final MainView mainView;
 
    @NotNull
    private final MapViewsManager<G, A, R> mapViewsManager;
 
    @NotNull
    private final String scriptExtension;
 
    @NotNull
    private final ScriptEditControl scriptEditControl;
 
    @NotNull
    private final NewMapDialogFactory<G, A, R> newMapDialogFactory;
 
    @NotNull
    private final DefaultFileControl<G, A, R> fileControl;
 
    @NotNull
    private final UpdaterManager updaterManager;
 
    public GUIMainControl(@NotNull final ProjectModel<G, A, R> projectModel, @NotNull final EditorSettings editorSettings, @NotNull final ErrorView errorView, @NotNull final ResourceIcons resourceIcons, @NotNull final EditorFactory<G, A, R> editorFactory, @NotNull final ConfigSourceFactory configSourceFactory) {
        this.projectModel = projectModel;
        final NamedFilter defaultNamedFilterList = new NamedFilter(projectModel.getGameObjectMatchers().getFilters());
        final FilterControl<G, A, R> filterControl = new DefaultFilterControl<>(defaultNamedFilterList, editorSettings);
        final MapViewSettings mapViewSettings = new DefaultMapViewSettings();
        final RendererFactory<G, A, R> rendererFactory = editorFactory.newRendererFactory(mapViewSettings, filterControl, projectModel.getGameObjectParser(), projectModel.getFaceObjectProviders(), resourceIcons, projectModel.getSmoothFaces());
        final MapViewFactory<G, A, R> mapViewFactory = editorFactory.newMapViewFactory(rendererFactory, projectModel.getPathManager());
        scriptExtension = editorFactory.getScriptExtension();
        final DisplayMode<G, A, R> displayModeGameObjectNames = new DisplayNameCellRenderer<>(projectModel.getFaceObjectProviders());
        final DisplayMode<G, A, R> displayModeArchetypeNames = new ArchetypeNameCellRenderer<>(projectModel.getFaceObjectProviders());
        final DisplayMode<G, A, R> displayModeIconsOnly = new ArchetypeIconCellRenderer<>(projectModel.getFaceObjectProviders());
        final ExitConnectorModel exitConnectorModel = new DefaultExitConnectorModel();
        final ShortcutsManager shortcutsManager = new ShortcutsManager(ACTION_BUILDER);
        final ImageCreator<G, A, R> imageCreator = new ImageCreator<>(projectModel.getMapManager(), rendererFactory);
        final VolatileSettings volatileSettings = new DefaultVolatileSettings(projectModel.getProjectSettings().getMapsDirectory());
        final ImageCreator2<G, A, R> imageCreator2 = new ImageCreator2<>(volatileSettings, imageCreator);
        final String spellFile = editorFactory.getSpellFile();
        final SpellsUtils spellUtils = spellFile == null ? null : new SpellsUtils(spellFile);
        final AppPreferencesModel appPreferencesModel = new AppPreferencesModel(ActionBuilderUtils.getString(ACTION_BUILDER, "serverDefault"), System.getProperty("os.name").toLowerCase().startsWith("win") ? ActionBuilderUtils.getString(ACTION_BUILDER, "clientDefaultWindows") : ActionBuilderUtils.getString(ACTION_BUILDER, "clientDefaultOther"), ActionBuilderUtils.getString(ACTION_BUILDER, "editorDefault"));
        final MapViewManager<G, A, R> mapViewManager = new MapViewManager<>();
        final StatusBar<G, A, R> statusBar = new StatusBar<>(projectModel.getMapManager(), mapViewManager, projectModel.getArchetypeSet(), projectModel.getFaceObjects());
        final MapImageCache<G, A, R> mapImageCache = new MapImageCache<>(projectModel.getMapManager(), resourceIcons.getResourceIcon(ResourceIcons.DEFAULT_ICON).getImage(), resourceIcons.getResourceIcon(ResourceIcons.DEFAULT_PREVIEW).getImage(), rendererFactory, editorFactory.getCacheFiles());
        final MapFolderTree<G, A, R> mapFolderTree = new MapFolderTree<>(projectModel.getProjectSettings().getPickmapDir());
        final ImageIcon icon = resourceIcons.getResourceIcon(ResourceIcons.APP_ICON);
        mainViewFrame = new JFrame(ACTION_BUILDER.format("mainWindow.title", getBuildNumberAsString()));
        final PickmapChooserModel<G, A, R> pickmapChooserModel = new PickmapChooserModel<>();
        final PickmapChooserView<G, A, R> pickmapChooserView = new PickmapChooserView<>(pickmapChooserModel, mapFolderTree, projectModel.getMapArchObjectFactory(), projectModel.getMapReaderFactory(), projectModel.getPickmapManager());
        final PickmapSettings pickmapSettings = new DefaultPickmapSettings();
        final CFTreasureListTree treasureListTree = new CFTreasureListTree(projectModel.getTreasureTree(), mainViewFrame, projectModel.getArchetypeSet(), projectModel.getFaceObjectProviders(), resourceIcons);
        final ImageIcon noFaceSquareIcon = resourceIcons.getResourceIcon(ResourceIcons.SQUARE_NO_FACE);
        final ImageIcon unknownSquareIcon = resourceIcons.getResourceIcon(ResourceIcons.SQUARE_UNKNOWN);
        final SelectedSquareModel<G, A, R> selectedSquareModel = new SelectedSquareModel<>();
        final GameObjectMatcher floorMatcher = projectModel.getGameObjectMatchers().getMatcher("system_floor", "floor");
        final GameObjectMatcher wallMatcher = projectModel.getGameObjectMatchers().getMatcher("system_wall", "wall");
        final ErrorViewCollector gameObjectMatchersErrorViewCollector = new ErrorViewCollector(errorView, new File(projectModel.getProjectSettings().getConfigurationDirectory(), "GameObjectMatchers.xml"));
        final GameObjectMatcher belowFloorMatcher = projectModel.getGameObjectMatchers().getMatcherWarn(gameObjectMatchersErrorViewCollector, "system_below_floor", "below_floor");
        final GameObjectMatcher systemObjectMatcher = projectModel.getGameObjectMatchers().getMatcher("system_system_object");
        final InsertionModeSet<G, A, R> insertionModeSet = new InsertionModeSet<>(projectModel.getTopmostInsertionMode(), floorMatcher, wallMatcher, belowFloorMatcher, systemObjectMatcher);
        final CopyBuffer<G, A, R> copyBuffer = new CopyBuffer<>(mapViewSettings, projectModel.getGameObjectFactory(), projectModel.getMapArchObjectFactory(), projectModel.getMapModelFactory(), insertionModeSet);
        final FindDialogManager<G, A, R> findDialogManager = new FindDialogManager<>(mainViewFrame, mapViewManager);
        final Exiter exiter = new DefaultExiter(mainViewFrame);
        scriptEditControl = new ScriptEditControl(editorFactory.getScriptFileFilter(), scriptExtension, mainViewFrame, projectModel.getProjectSettings().getMapsDirectory(), PREFERENCES, exiter, appPreferencesModel, statusBar);
        final MenuEntries menuEntries = new MenuEntries();
        final TextAreaDefaults textAreaDefaults = new TextAreaDefaults(scriptEditControl, menuEntries);
        scriptEditControl.setTextAreaDefaults(textAreaDefaults);
        final GameObjectAttributesDialogFactory<G, A, R> gameObjectAttributesDialogFactory = new GameObjectAttributesDialogFactory<>(projectModel.getArchetypeTypeSet(), mainViewFrame, treasureListTree, projectModel.getFaceObjectProviders(), projectModel.getAnimationObjects(), projectModel.getProjectSettings(), editorFactory.getMapFileFilter(), editorFactory.getScriptFileFilter(), projectModel.getFaceObjects(), projectModel.getGameObjectSpells(), projectModel.getNumberSpells(), editorFactory.getUndefinedSpellIndex(), projectModel.getTreasureTree(), noFaceSquareIcon, unknownSquareIcon, textAreaDefaults, projectModel.getMapManager());
        final ScriptedEventEditor<G, A, R> scriptedEventEditor = new ScriptedEventEditor<>(projectModel.getProjectSettings(), scriptEditControl);
        final ScriptArchUtils scriptArchUtils = DefaultMainControl.loadScriptArchUtils(errorView, editorFactory, projectModel.getArchetypeTypeSet());
        final ScriptedEventFactory<G, A, R> scriptedEventFactory = editorFactory.newScriptedEventFactory(scriptArchUtils, projectModel.getGameObjectFactory(), scriptedEventEditor, projectModel.getArchetypeSet());
        final ScriptArchEditor<G, A, R> scriptArchEditor = new ScriptArchEditor<>(scriptedEventFactory, editorFactory.getScriptExtension(), editorFactory.getScriptName(), scriptArchUtils, editorFactory.getScriptFileFilter(), projectModel.getProjectSettings(), projectModel.getMapManager(), projectModel.getPathManager(), scriptEditControl);
        final ScriptArchDataUtils<G, A, R> scriptArchDataUtils = editorFactory.newScriptArchDataUtils(scriptArchUtils, scriptedEventFactory, scriptedEventEditor);
        final GameObjectMatcher monsterMatcherTmp = projectModel.getGameObjectMatchers().getMatcherWarn(gameObjectMatchersErrorViewCollector, "system_monster", "monster");
        final GameObjectMatcher monsterMatcher = monsterMatcherTmp == null ? new TypeNrsGameObjectMatcher() : monsterMatcherTmp;
        final GameObjectMatcher exitGameObjectMatcherTmp = projectModel.getGameObjectMatchers().getMatcherWarn(gameObjectMatchersErrorViewCollector, "system_exit", "exit");
        final GameObjectMatcher exitGameObjectMatcher = exitGameObjectMatcherTmp == null ? new TypeNrsGameObjectMatcher() : exitGameObjectMatcherTmp;
        final ExitMatcher<G, A, R> exitMatcher = new ExitMatcher<>(exitGameObjectMatcher);
        final MapPropertiesDialogFactory<G, A, R> mapPropertiesDialogFactory = editorFactory.newMapPropertiesDialogFactory(projectModel.getProjectSettings(), projectModel.getMapManager());
        final DelayedMapModelListenerManager<G, A, R> delayedMapModelListenerManager = new DelayedMapModelListenerManager<>(projectModel.getMapManager(), exiter);
        final Control<?, G, A, R> lockedItemsControl = new LockedItemsControl<>(mapViewManager, delayedMapModelListenerManager, editorFactory.getLockedItemsTypeNumbers());
        final GameObjectAttributesModel<G, A, R> gameObjectAttributesModel = new GameObjectAttributesModel<>();
        final File scriptsFile = new File(projectModel.getProjectSettings().getMapsDirectory(), editorFactory.getScriptsDir());
        updaterManager = new UpdaterManager(exiter, projectModel.getMapManager(), mainViewFrame, editorFactory.getGridartaJarFilename());
        final TextEditorTab<G, A, R> textEditorTab = new TextEditorTab<>(gameObjectAttributesModel, projectModel.getArchetypeTypeSet());
        final EditorAction undoControl = new UndoControl<>(projectModel.getMapManager(), projectModel.getGameObjectFactory(), projectModel.getGameObjectMatchers());
        final EditorActionManager<G, A, R> editorActionManager = new EditorActionManager<>(mapViewManager);
        final Action displayGameObjectNamesAction = editorActionManager.createAction("displayGameObjectNames", "Archetype Chooser", new DisplayGameObjectNamesAction<>(projectModel.getArchetypeChooserModel(), displayModeArchetypeNames));
        final Action displayIconsOnlyAction = editorActionManager.createAction("displayIconsOnly", "Archetype Chooser", new DisplayIconsOnlyAction<>(projectModel.getArchetypeChooserModel(), displayModeIconsOnly));
        final Action displayArchetypeNamesAction = editorActionManager.createAction("displayArchetypeNames", "Archetype Chooser", new DisplayArchetypeNamesAction<>(projectModel.getArchetypeChooserModel(), displayModeGameObjectNames));
        final ArchetypeChooserView<G, A, R> archetypeChooserView = new ArchetypeChooserView<>(editorFactory.isCreateDirectionPane(), projectModel.getArchetypeChooserModel(), projectModel.getFaceObjectProviders(), displayGameObjectNamesAction, displayArchetypeNamesAction, displayIconsOnlyAction, displayModeGameObjectNames, displayModeArchetypeNames, displayModeIconsOnly);
        final ArchetypeChooserControl<G, A, R> archetypeChooserControl = new ArchetypeChooserControl<>(projectModel.getArchetypeChooserModel(), archetypeChooserView);
        mapViewsManager = new MapViewsManager<>(mapViewSettings, mapViewFactory, projectModel.getMapManager(), projectModel.getPickmapManager(), projectModel.getPathManager());
        newMapDialogFactory = editorFactory.newNewMapDialogFactory(mapViewsManager, projectModel.getMapArchObjectFactory(), pickmapChooserView, mainViewFrame);
        fileControl = new DefaultFileControl<>(projectModel.getProjectSettings(), volatileSettings, mapImageCache, projectModel.getMapManager(), mapViewsManager, mainViewFrame, GuiFileFilters.MAP_FILE_FILTER, editorFactory.getScriptFileFilter(), newMapDialogFactory, scriptExtension, scriptEditControl, projectModel.getPathManager());
        mapViewsManager.setFileControl(fileControl);
        final PickmapChooserControl<G, A, R> pickmapChooserControl = new PickmapChooserControl<>(pickmapChooserModel, pickmapSettings, newMapDialogFactory, mapFolderTree, projectModel.getMapManager(), mainViewFrame, mapViewsManager, fileControl, pickmapChooserView);
        final DefaultObjectChooser<G, A, R> objectChooser = new DefaultObjectChooser<>(archetypeChooserControl, pickmapChooserControl, projectModel.getArchetypeChooserModel(), pickmapChooserModel, projectModel.getArchetypeTypeSet());
        newMapDialogFactory.setObjectChooser(objectChooser);
        final MapDesktop<G, A, R> mapDesktop = new MapDesktop<>(mapViewManager, projectModel.getMapManager(), mapImageCache, mapViewsManager);
        final EnterMap<G, A, R> enterMap = new EnterMap<>(mainViewFrame, editorFactory.getDirectionMap(), fileControl, mapViewsManager);
        final MapActions<G, A, R> mapActions = new MapActions<>(mainViewFrame, projectModel.getMapManager(), mapViewManager, exitMatcher, GuiFileFilters.MAP_FILE_FILTER, selectedSquareModel, editorFactory.isAllowRandomMapParameters(), mapPropertiesDialogFactory, mapViewSettings, mapViewsManager, enterMap, projectModel.getProjectSettings());
        final MapFolderTreeActions<G, A, R> mapFolderTreeActions = new MapFolderTreeActions<>(mapFolderTree, pickmapSettings, newMapDialogFactory, "createPickmapFolder", "deletePickmapFolder", "confirmDeletePickmapFolder", "deletePickmapFolderNotEmpty");
        final ViewActions<G, A, R> viewActions = new ViewActions<>(mapViewSettings, projectModel.getMapManager());
        final EditorAction mapFileActions = new MapFileActions<>(imageCreator2, projectModel.getMapManager(), mapViewsManager, mapViewManager, fileControl, mainViewFrame);
        final BookmarksMapMenuPreferences bookmarksMapMenuPreferences = new BookmarksMapMenuPreferences(projectModel.getPathManager());
        final MapMenu mapMenu = bookmarksMapMenuPreferences.getMapMenu();
        final MapMenuManager<G, A, R> bookmarksMapMenuManager = new MapMenuManager<>(mapMenu, mapViewsManager, fileControl, mapImageCache);
        final ExitConnectorActions<G, A, R> exitConnectorActions = new ExitConnectorActions<>(exitConnectorModel, exitMatcher, projectModel.getArchetypeSet(), projectModel.getMapManager(), fileControl, insertionModeSet); // XXX: should be part of DefaultMainControl
        final EditorAction exitConnectorController = new ExitConnectorController<>(exitConnectorActions, exitConnectorModel);
        final ToolPalette<G, A, R> toolPalette = new ToolPalette<>(mapViewSettings, selectedSquareModel, objectChooser, pickmapSettings, floorMatcher, wallMatcher, monsterMatcher, insertionModeSet);
        final GameObjectAttributesControl<G, A, R> gameObjectAttributesControl = new GameObjectAttributesControl<>(gameObjectAttributesModel, gameObjectAttributesDialogFactory, objectChooser, projectModel.getMapManager(), selectedSquareModel, projectModel.getGameObjectFactory(), mapViewSettings);
        final GameObjectTab<G, A, R> gameObjectTab = new GameObjectTab<>("gameObject", gameObjectAttributesControl, Location.BOTTOM, false, 0, true);
        final ReplaceDialogManager<G, A, R> replaceDialogManager = new ReplaceDialogManager<>(mainViewFrame, copyBuffer, objectChooser, mapViewManager, projectModel.getFaceObjectProviders(), insertionModeSet);
        final PluginParameterViewFactory<G, A, R> pluginParameterViewFactory = new PluginParameterViewFactory<>(projectModel.getArchetypeSet(), gameObjectAttributesModel, objectChooser, projectModel.getMapManager(), projectModel.getFaceObjectProviders(), projectModel.getPathManager());
        final PluginController<G, A, R> pluginControl = new PluginController<>(filterControl, projectModel.getPluginModel(), projectModel.newPluginParameters(rendererFactory), mainViewFrame, pluginParameterViewFactory, scriptsFile, resourceIcons);
        final EditorAction mainActions = new MainActions<>(findDialogManager, replaceDialogManager, mainViewFrame, mapViewSettings, projectModel.getArchetypeSet(), copyBuffer, objectChooser, projectModel.getMapManager(), insertionModeSet);
        final EditorAction mapCursorActions = new MapCursorActions<>(mapActions);
        final Action moveSquareDownAction = editorActionManager.createAction("moveSquareDown", "Selected Square View", new MoveSquareDownAction<>(selectedSquareModel, projectModel.getMapManager()));
        final Action moveSquareUpAction = editorActionManager.createAction("moveSquareUp", "Selected Square View", new MoveSquareUpAction<>(selectedSquareModel, projectModel.getMapManager()));
        final Action moveSquareBottomAction = editorActionManager.createAction("moveSquareBottom", "Selected Square View", new MoveSquareBottomAction<>(selectedSquareModel, projectModel.getMapManager()));
        final Action moveSquareEnvAction = editorActionManager.createAction("moveSquareEnv", "Selected Square View", new MoveSquareEnvAction<>(selectedSquareModel, projectModel.getMapManager()));
        final Action moveSquareInvAction = editorActionManager.createAction("moveSquareInv", "Selected Square View", new MoveSquareInvAction<>(selectedSquareModel, projectModel.getMapManager()));
        final Action moveSquareTopAction = editorActionManager.createAction("moveSquareTop", "Selected Square View", new MoveSquareTopAction<>(selectedSquareModel, projectModel.getMapManager()));
        editorActionManager.createAction("findArchetypes", "Archetypes", new FindArchetypesAction<>(mainViewFrame, archetypeChooserControl, objectChooser, projectModel.getArchetypeTypeSet()));
        editorActionManager.createAction("browseArchetypes", "Archetypes", new BrowseArchetypesAction<>(mainViewFrame, archetypeChooserControl, objectChooser, projectModel.getArchetypeSet(), resourceIcons.getResourceIcon(ResourceIcons.CLOSE_TAB_SMALL_ICON)));
        editorActionManager.createAction("moveSquarePrev", "Selected Square View", new MoveSquarePrevAction<>(selectedSquareModel, projectModel.getMapManager()));
        editorActionManager.createAction("moveSquareNext", "Selected Square View", new MoveSquareNextAction<>(selectedSquareModel, projectModel.getMapManager()));
        editorActionManager.createAction("prevWindow", "Map,Window", mapDesktop);
        editorActionManager.createAction("nextWindow", "Map,Window", mapDesktop);
        editorActionManager.createAction("addNewPickmap", "Pickmap", pickmapChooserControl);
        editorActionManager.createAction("openPickmapMap", "Pickmap", pickmapChooserControl);
        editorActionManager.createAction("deletePickmap", "Pickmap", pickmapChooserControl);
        editorActionManager.createAction("savePickmap", "Pickmap", pickmapChooserControl);
        editorActionManager.createAction("revertPickmap", "Pickmap", pickmapChooserControl);
        editorActionManager.createAction("viewTreasurelists", "Tool", new ViewTreasurelistsAction(treasureListTree, mainViewFrame));
        editorActionManager.createAction("mapCreateView", "Map,Window", mapActions);
        editorActionManager.createAction("mapProperties", "Map", mapActions);
        editorActionManager.createToggleAction("autoJoin", "Map", mapActions);
        editorActionManager.createAction("shrinkMapSize", "Map", mapActions);
        editorActionManager.createAction("enterExit", "Map Navigation", mapActions);
        editorActionManager.createAction("nextExit", "Map Navigation", mapActions);
        editorActionManager.createAction("prevExit", "Map Navigation", mapActions);
        editorActionManager.createAction("deleteUnknownObjects", "Map Navigation", mapActions);
        editorActionManager.createAction("enterNorthMap", "Map Navigation", mapActions);
        editorActionManager.createAction("enterEastMap", "Map Navigation", mapActions);
        editorActionManager.createAction("enterSouthMap", "Map Navigation", mapActions);
        editorActionManager.createAction("enterWestMap", "Map Navigation", mapActions);
        editorActionManager.createAction("enterNorthEastMap", "Map Navigation", mapActions);
        editorActionManager.createAction("enterSouthEastMap", "Map Navigation", mapActions);
        editorActionManager.createAction("enterSouthWestMap", "Map Navigation", mapActions);
        editorActionManager.createAction("enterNorthWestMap", "Map Navigation", mapActions);
        editorActionManager.createAction("enterUpMap", "Map Navigation", mapActions);
        editorActionManager.createAction("enterDownMap", "Map Navigation", mapActions);
        editorActionManager.createAction("createTileNorth", "Map/Create Tile", mapActions);
        editorActionManager.createAction("createTileEast", "Map/Create Tile", mapActions);
        editorActionManager.createAction("createTileSouth", "Map/Create Tile", mapActions);
        editorActionManager.createAction("createTileWest", "Map/Create Tile", mapActions);
        editorActionManager.createAction("createTileNorthEast", "Map/Create Tile", mapActions);
        editorActionManager.createAction("createTileSouthEast", "Map/Create Tile", mapActions);
        editorActionManager.createAction("createTileSouthWest", "Map/Create Tile", mapActions);
        editorActionManager.createAction("createTileNorthWest", "Map/Create Tile", mapActions);
        editorActionManager.createAction("createTileUp", "Map/Create Tile", mapActions);
        editorActionManager.createAction("createTileDown", "Map/Create Tile", mapActions);
        editorActionManager.createToggleAction("gridVisible", "Map Navigation", mapActions);
        editorActionManager.createToggleAction("lightVisible", "Map Navigation", new LightVisibleAction(mapViewSettings));
        editorActionManager.createToggleAction("smoothing", "Map Navigation", mapActions);
        editorActionManager.createToggleAction("doubleFaces", "Map Navigation", mapActions);
        editorActionManager.createToggleAction("tileShow", "Map Navigation", mapActions);
        editorActionManager.createToggleAction("tileStretching", "Map Navigation", mapActions);
        editorActionManager.createAction("editPlugins", "Plugin", new PluginManagerFactory<>(mainViewFrame, pluginControl, projectModel.getPluginModel(), pluginParameterViewFactory, resourceIcons));
        editorActionManager.createAction("savePlugins", "Plugin", new SavePluginsAction<>(pluginControl));
        editorActionManager.createAction("importPlugin", "Plugin", new ImportPluginAction<>(projectModel.getPluginModel(), mainViewFrame));
        editorActionManager.createAction("update", "Tool", updaterManager);
        editorActionManager.createAction("about", "Help", new About(mainViewFrame));
        editorActionManager.createAction("undo", "Undo", undoControl);
        editorActionManager.createAction("redo", "Undo", undoControl);
        final Action exitAction = editorActionManager.createAction("exit", "Other", new ExitAction(exiter, scriptEditControl, fileControl, pickmapChooserControl, pluginControl));
        mainView = new MainView(mainViewFrame, exitAction, mapDesktop, icon, exiter);
        editorActionManager.createAction("createPickmapFolder", "Pickmap", mapFolderTreeActions);
        editorActionManager.createAction("deletePickmapFolder", "Pickmap", mapFolderTreeActions);
        editorActionManager.createAction("resetView", "Map", viewActions);
        editorActionManager.createAction("saveMap", "Map", mapFileActions);
        editorActionManager.createAction("saveMapAs", "Map", mapFileActions);
        editorActionManager.createAction("createImage", "Map,Image", mapFileActions);
        editorActionManager.createAction("reloadMap", "Map", mapFileActions);
        editorActionManager.createAction("closeMap", "Map", mapFileActions);
        editorActionManager.createAction("clear", "Copy Buffer", mainActions);
        editorActionManager.createAction("cut", "Copy Buffer", mainActions);
        editorActionManager.createAction("copy", "Copy Buffer", mainActions);
        editorActionManager.createAction("paste", "Copy Buffer", mainActions);
        editorActionManager.createAction("pasteTiled", "Copy Buffer", mainActions);
        editorActionManager.createAction("shiftNorth", "Map/Shift", mainActions);
        editorActionManager.createAction("shiftNorthEast", "Map/Shift", mainActions);
        editorActionManager.createAction("shiftEast", "Map/Shift", mainActions);
        editorActionManager.createAction("shiftSouthEast", "Map/Shift", mainActions);
        editorActionManager.createAction("shiftSouth", "Map/Shift", mainActions);
        editorActionManager.createAction("shiftSouthWest", "Map/Shift", mainActions);
        editorActionManager.createAction("shiftWest", "Map/Shift", mainActions);
        editorActionManager.createAction("shiftNorthWest", "Map/Shift", mainActions);
        editorActionManager.createAction("find", "Map", mainActions);
        editorActionManager.createAction("findNext", "Map", mainActions);
        editorActionManager.createAction("findPrev", "Map", mainActions);
        editorActionManager.createAction("replace", "Map", mainActions);
        editorActionManager.createAction("fillAuto", "Map/Fill", mainActions);
        editorActionManager.createAction("fillAbove", "Map/Fill", mainActions);
        editorActionManager.createAction("fillBelow", "Map/Fill", mainActions);
        editorActionManager.createAction("randFillAuto", "Map/Fill", mainActions);
        editorActionManager.createAction("randFillAbove", "Map/Fill", mainActions);
        editorActionManager.createAction("randFillBelow", "Map/Fill", mainActions);
        editorActionManager.createAction("floodFill", "Map/Fill", mainActions);
        editorActionManager.createAction("massChange", "Map", mainActions);
        editorActionManager.createAction("selectAll", "Map/Selection", mainActions);
        editorActionManager.createAction("invertSelection", "Map/Selection", mainActions);
        editorActionManager.createAction("expandEmptySelection", "Map/Selection", mainActions);
        editorActionManager.createAction("tileStretchingSet", "Map,Tile Stretching", mainActions);
        editorActionManager.createAction("tileStretchingClear", "Map,Tile Stretching", mainActions);
        editorActionManager.createAction("tileStretchingIncrease", "Map,Tile Stretching", mainActions);
        editorActionManager.createAction("tileStretchingDecrease", "Map,Tile Stretching", mainActions);
        editorActionManager.createAction("growSelection", "Map/Selection", new GrowSelectionAction<G, A, R>());
        editorActionManager.createAction("shrinkSelection", "Map/Selection", new ShrinkSelectionAction<G, A, R>());
        editorActionManager.createAction("collectArches", "Tool", new CollectArchesAction<>(projectModel.getProjectSettings(), projectModel.getResources(), exiter, mainViewFrame));
        editorActionManager.createAction("reloadFaces", "Image,Tool", new ReloadFacesAction<>(projectModel.getArchetypeSet(), projectModel.getFaceObjectProviders()));
        editorActionManager.createAction("validateMap", "Map,Tool", new ValidateMapAction<>(projectModel.getValidators(), projectModel.getMapManager()));
        editorActionManager.createAction("exportMapAsImage", "Map,Tool", new ExportMapAsImageAction<>(projectModel.getMapManager(), rendererFactory, mainViewFrame));
        editorActionManager.createAction("showHelp", "Help", new ShowHelpAction(mainViewFrame));
        editorActionManager.createAction("tipOfTheDay", "Help", new TipOfTheDayAction(mainViewFrame));
        editorActionManager.createAction("newMap", "Map", new NewMapAction<>(newMapDialogFactory));
        editorActionManager.createAction("goMap", "Map", new GoMapDialogManager<>(mainViewFrame, projectModel.getMapManager(), mapViewsManager, projectModel.getProjectSettings(), exiter));
        editorActionManager.createAction("goExit", "Map Navigation", new GoExitDialogManager<>(mainViewFrame, projectModel.getMapManager(), mapViewManager, exitGameObjectMatcher, enterMap, projectModel.getFaceObjectProviders()));
        editorActionManager.createAction("cleanCompletelyBlockedSquares", "Tool", new CleanCompletelyBlockedSquaresAction<>(projectModel.getMapManager()));
        editorActionManager.createAction("collectSpells", "Tool", new CollectSpellsAction(spellUtils, projectModel.getProjectSettings(), mainViewFrame));
        editorActionManager.createAction("controlClient", "Tool", new ControlClientAction(appPreferencesModel, mainViewFrame));
        editorActionManager.createAction("controlServer", "Tool", new ControlServerAction(appPreferencesModel, mainViewFrame));
        editorActionManager.createAction("gc", "Tool", new GcAction(statusBar));
        editorActionManager.createAction("options", "Tool", new OptionsAction<>(editorFactory, projectModel.getProjectSettings(), editorSettings, projectModel.getValidators(), appPreferencesModel, exitConnectorModel, configSourceFactory, mainViewFrame));
        editorActionManager.createAction("shortcuts", "Tool", new ShortcutsAction(shortcutsManager, mainViewFrame));
        editorActionManager.createAction("zoom", "Tool", new ZoomAction<>(projectModel.getMapManager(), rendererFactory));
        editorActionManager.createAction("moveCursorNorth", "Map Cursor,Map/Selection", mapCursorActions);
        editorActionManager.createAction("moveCursorEast", "Map Cursor,Map/Selection", mapCursorActions);
        editorActionManager.createAction("moveCursorSouth", "Map Cursor,Map/Selection", mapCursorActions);
        editorActionManager.createAction("moveCursorWest", "Map Cursor,Map/Selection", mapCursorActions);
        editorActionManager.createAction("moveCursorNorthEast", "Map Cursor,Map/Selection", mapCursorActions);
        editorActionManager.createAction("moveCursorSouthEast", "Map Cursor,Map/Selection", mapCursorActions);
        editorActionManager.createAction("moveCursorSouthWest", "Map Cursor,Map/Selection", mapCursorActions);
        editorActionManager.createAction("moveCursorNorthWest", "Map Cursor,Map/Selection", mapCursorActions);
        editorActionManager.createAction("goLocation", "Map Cursor", new GoLocationAction<>(mapViewManager));
        editorActionManager.createAction("selectSquare", "Map Cursor,Map/Selection", new SelectSquareAction<G, A, R>());
        editorActionManager.createAction("addToSelection", "Map Cursor,Map/Selection", new AddToSelectionAction<G, A, R>());
        editorActionManager.createAction("subFromSelection", "Map Cursor,Map/Selection", new SubFromSelectionAction<G, A, R>());
        editorActionManager.createAction("startStopDrag", "Map Cursor,Map/Selection", new StartStopDragAction<G, A, R>());
        editorActionManager.createAction("releaseDrag", "Map Cursor,Map/Selection", new ReleaseDragAction<G, A, R>());
        editorActionManager.createAction("insertArch", "Map Cursor,Map", new InsertArchAction<>(objectChooser, mapViewSettings));
        editorActionManager.createAction("deleteArch", "Map Cursor,Map", new DeleteArchAction<G, A, R>(mapViewSettings));
        editorActionManager.createAction("selectArchAbove", "Map Cursor,Selected Square View", new SelectArchBelowAction<G, A, R>());
        editorActionManager.createAction("selectArchBelow", "Map Cursor,Selected Square View", new SelectArchAboveAction<G, A, R>());
        editorActionManager.createAction("archAttributes", "Map", new ArchAttributesAction<>(gameObjectAttributesDialogFactory));
        editorActionManager.createAction("newScript", "Script", scriptEditControl);
        editorActionManager.createAction("editScript", "Script", new EditScriptAction<>(fileControl));
        editorActionManager.createAction("openFile", "Map", new OpenFileAction<>(fileControl));
        editorActionManager.createAction("saveAllMaps", "Map", new SaveAllMapsAction<>(fileControl));
        final Action aCloseAllMaps = editorActionManager.createAction("closeAllMaps", "Map,Window", new CloseAllMapsAction<>(fileControl));
        editorActionManager.createAction("gameObjectTextEditor", "Tool", new MainViewActions<>(mainView, gameObjectAttributesControl, gameObjectTab, textEditorTab));
        editorActionManager.createAction("manageBookmarks", "Bookmarks", new ManageBookmarksAction<>(mapMenu, mapImageCache, mainViewFrame));
        editorActionManager.createAction("addBookmark", "Bookmarks", new AddBookmarkAction<G, A, R>(bookmarksMapMenuPreferences));
        editorActionManager.createActionOptional("openInClient", "Map", editorFactory.newServerActions(fileControl));
        editorActionManager.createAction("exitCopy", "Exit Connector", exitConnectorController);
        editorActionManager.createAction("exitPaste", "Exit Connector", exitConnectorController);
        editorActionManager.createAction("exitConnect", "Exit Connector", exitConnectorController);
        pickmapChooserControl.setPopupMenu(ACTION_BUILDER.createPopupMenu(true, "pickmaps"));
        final JMenuBar menuBar = ACTION_BUILDER.createMenuBar(true, "main");
        mainViewFrame.setJMenuBar(menuBar);
        mainViewFrame.add(new MainToolbar(editorSettings).getComponent(), BorderLayout.NORTH);
        mainViewFrame.add(statusBar, BorderLayout.SOUTH);
        mainView.addTab(gameObjectTab);
        final String compassIconName = editorFactory.getCompassIconName();
        final ImageIcon compassIcon = compassIconName == null ? null : resourceIcons.getResourceIcon(compassIconName);
        mainView.addTab(new Tab("selectedSquare", new SelectedSquareView<>(selectedSquareModel, gameObjectAttributesDialogFactory, objectChooser, mapViewManager, mapViewSettings, compassIcon, projectModel.getFaceObjectProviders(), unknownSquareIcon, moveSquareUpAction, moveSquareDownAction, moveSquareTopAction, moveSquareBottomAction, moveSquareEnvAction, moveSquareInvAction), Location.RIGHT, false, 1, true));
        mainView.addTab(new Tab("tools", toolPalette, Location.LEFT, false, 2, false));
        mainView.addTab(new Tab("objects", objectChooser, Location.LEFT, false, 3, true));
        final JMenu windowMenu = MenuUtils.getMenu(menuBar, "window");
        if (windowMenu == null) {
            LOG.warn("'main' menu bar does not define 'window' menu.");
        } else {
            //noinspection ResultOfObjectAllocationIgnored
            new WindowMenuManager<>(windowMenu, mapViewManager, aCloseAllMaps, mapDesktop);
        }
        final JMenu pickmapFoldersMenu = MenuUtils.getMenu(menuBar, "pickmapFolders");
        if (pickmapFoldersMenu == null) {
            LOG.warn("'main' menu bar does not define 'pickmapFolders' menu.");
        } else {
            mapFolderTreeActions.setPickmapFoldersMenu(pickmapFoldersMenu);
        }
        viewActions.init(projectModel.getGameObjectMatchers().getFilters());
        final Container viewMenu = MenuUtils.getMenu(menuBar, "view");
        if (viewMenu == null) {
            LOG.warn("'main' menu bar does not define 'view' menu.");
        } else {
            viewActions.setMenu(viewMenu);
        }
        final JMenu pluginsMenu = MenuUtils.getMenu(menuBar, "plugins");
        if (pluginsMenu == null) {
            LOG.warn("'main' menu bar does not define 'plugins' menu.");
        } else {
            pluginControl.getView().setMenu(pluginsMenu);
        }
        final ErrorListView<G, A, R> errorListView = new ErrorListView<>(mapViewManager);
        gameObjectAttributesControl.addTab(new ArchTab<>(projectModel.getArchetypeTypeSet(), gameObjectAttributesModel));
        gameObjectAttributesControl.addTab(new MsgTextTab<>(gameObjectAttributesModel));
        gameObjectAttributesControl.addTab(new EventsTab<>(mainViewFrame, projectModel.getMapManager(), gameObjectAttributesModel, scriptArchEditor, editorFactory.newScriptArchData(), scriptArchDataUtils, scriptArchUtils));
        gameObjectAttributesControl.addTab(new FaceTab<>(gameObjectAttributesModel, projectModel.getFaceObjects(), projectModel.getFaceObjectProviders(), projectModel.getAnimationObjects(), noFaceSquareIcon, unknownSquareIcon));
        gameObjectAttributesControl.addTab(textEditorTab);
        mainView.addTab(new Tab("monsters", new MonsterControl<>(mapViewManager, delayedMapModelListenerManager, monsterMatcher).getView(), Location.BOTTOM, false, 4, false));
        mainView.addTab(new Tab("connections", new ConnectionControl<>(mapViewManager, delayedMapModelListenerManager).getView(), Location.BOTTOM, false, 5, false));
        mainView.addTab(new Tab("lockedItems", lockedItemsControl.getView(), Location.BOTTOM, false, 6, false));
        mainView.addTab(new WarningsTab<>("warnings", errorListView, Location.BOTTOM, false, 7, false));
        mainView.addTab(new GameObjectTextEditorTab<>("textEditor", new GameObjectTextEditor(projectModel.getArchetypeTypeSet()), Location.RIGHT, true, 8, false, selectedSquareModel, projectModel.getMapManager()));
 
        new ArchetypeValidator(projectModel.getAnimationObjects(), projectModel.getFaceObjects(), errorView).validate(projectModel.getArchetypeSet());
        new AnimationValidator(projectModel.getFaceObjects(), errorView).validate(projectModel.getAnimationObjects());
 
        final MapMenuPreferences recentMapMenuPreferences = new RecentMapMenuPreferences(projectModel.getPathManager());
        final MapMenuManager<G, A, R> recentMapMenuManager = new MapMenuManager<>(recentMapMenuPreferences.getMapMenu(), mapViewsManager, fileControl, mapImageCache);
        final JMenu recentMenu = MenuUtils.getMenu(menuBar, "recent");
        if (recentMenu == null) {
            LOG.warn("'main' menu bar does not define 'recent' menu.");
        } else {
            recentMapMenuManager.setMenu(recentMenu);
        }
 
        final JMenu bookmarksMenu = MenuUtils.getMenu(menuBar, "bookmarks");
        if (bookmarksMenu == null) {
            LOG.warn("'main' menu bar does not define 'bookmarks' menu.");
        } else {
            bookmarksMapMenuManager.setMenu(bookmarksMenu);
        }
 
        final JMenu analyzeMenu = MenuUtils.getMenu(menuBar, "analyze");
        if (analyzeMenu == null) {
            LOG.warn("'main' menu bar does not define 'analyze' menu.");
        } else {
            filterControl.createMenuEntries(analyzeMenu);
        }
        final MapUserListenerManager<G, A, R> mapUserListenerManager = new MapUserListenerManager<>(toolPalette, mapViewsManager);
        mapUserListenerManager.addMapManager(projectModel.getMapManager());
        mapUserListenerManager.addMapManager(projectModel.getPickmapManager());
 
        new MapKeyListener<>(mapViewManager, projectModel.getMapManager());
 
        new Loader<>(errorView, mapFolderTree, projectModel.getMapReaderFactory(), projectModel.getPickmapManager(), mapViewsManager).load();
        if (!pickmapChooserModel.isEmpty()) {
            objectChooser.movePickmapChooserToFront();
        }
        recentMapMenuManager.initRecent();
        bookmarksMapMenuManager.initRecent();
 
        //noinspection ResultOfObjectAllocationIgnored
        new RecentManager<>(projectModel.getMapManager(), recentMapMenuPreferences);
 
        //noinspection ResultOfObjectAllocationIgnored
        new AutoValidator<>(projectModel.getValidators(), editorFactory.isAutoValidatorDefault(), delayedMapModelListenerManager);
        projectModel.getMapManager().setFileControl(fileControl);
        shortcutsManager.loadShortcuts();
        delayedMapModelListenerManager.start();
    }
 
    @NotNull
    private static String getBuildNumberAsString() {
        try {
            return ResourceBundle.getBundle("build").getString("build.number");
        } catch (final MissingResourceException ignored) {
            return "unknown version";
        }
    }
 
    private void openFile(@NotNull final File file) throws IOException {
        final boolean isScriptFile = file.getName().toLowerCase().endsWith(scriptExtension);
        if (file.isFile()) {
            if (isScriptFile) {
                scriptEditControl.openScriptFile(file);
            } else {
                mapViewsManager.openMapFileWithView(file, null, null);
            }
        } else if (!file.exists()) {
            if (isScriptFile) {
                // TODO: pass filename
                scriptEditControl.newScript();
            } else {
                newMapDialogFactory.showNewMapDialog(); // XXX: pass file
            }
        } // If neither branch matches, it's a directory - what to do with directories?
    }
 
    private void openFiles(@NotNull final List<File> files) {
        for (int i = files.size() - 1; i >= 0; i--) {
            final File file = files.get(i);
            try {
                openFile(file);
            } catch (final IOException ex) {
                fileControl.reportLoadError(file, ex.getMessage());
            }
        }
    }
 
    @Override
    public void handleThrowable(@NotNull final Throwable t) {
        mainView.handleThrowable(t);
    }
 
    public void run(@NotNull final List<File> args) {
        mainViewFrame.setVisible(true);
        TipOfTheDayManager.showAtStartup(mainViewFrame);
        updaterManager.startup();
 
        if (projectModel.getArchetypeSet().getArchetypeCount() == 0) {
            ACTION_BUILDER.showMessageDialog(mainViewFrame, "loadArchesNoArchetypes");
        }
 
        openFiles(args);
    }
 
}