Initial steps for saving settings in Leaderboard.html

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/leaderboard/AbstractLeaderboardComponentContext.java

@@ -0,0 +1,83 @@
+package com.sap.sailing.gwt.ui.leaderboard;
+
+import java.util.Map;
+
+import com.sap.sse.common.settings.Settings;
+import com.sap.sse.gwt.client.shared.perspective.AbstractComponentContextWithSettingsStorage;
+import com.sap.sse.gwt.client.shared.perspective.PerspectiveCompositeSettings;
+import com.sap.sse.gwt.client.shared.perspective.SettingsStorageManager;
+
+public abstract class AbstractLeaderboardComponentContext<L extends AbstractLeaderboardPerspectiveLifecycle> extends
+        AbstractComponentContextWithSettingsStorage<L, PerspectiveCompositeSettings<LeaderboardPerspectiveOwnSettings>> {
+
+    public AbstractLeaderboardComponentContext(L rootLifecycle,
+            SettingsStorageManager<PerspectiveCompositeSettings<LeaderboardPerspectiveOwnSettings>> settingsStorageManager) {
+        super(rootLifecycle, settingsStorageManager);
+    }
+
+    @Override
+    protected PerspectiveCompositeSettings<LeaderboardPerspectiveOwnSettings> extractContextSpecificSettings(
+            PerspectiveCompositeSettings<LeaderboardPerspectiveOwnSettings> newRootSettings) {
+        // TODO extract common logic (copied from RaceBoard)
+        String leaderboardComponentId = rootLifecycle.getLeaderboardPanelLifecycle().getComponentId();
+        LeaderboardSettings leaderboardSettings = (LeaderboardSettings) newRootSettings.getSettingsPerComponentId()
+                .get(leaderboardComponentId);
+        PerspectiveCompositeSettings<LeaderboardPerspectiveOwnSettings> defaultSettings = rootLifecycle
+                .createDefaultSettings();
+        LeaderboardSettings defaultLeaderboardSettings = leaderboardSettings.getDefaultSettings();
+        LeaderboardSettings contextSpecificLeaderboardSettings = new LeaderboardSettings(
+                defaultLeaderboardSettings.getManeuverDetailsToShow(), defaultLeaderboardSettings.getLegDetailsToShow(),
+                defaultLeaderboardSettings.getRaceDetailsToShow(), defaultLeaderboardSettings.getOverallDetailsToShow(),
+                leaderboardSettings.getNamesOfRaceColumnsToShow(), leaderboardSettings.getNamesOfRacesToShow(),
+                defaultLeaderboardSettings.getNumberOfLastRacesToShow(),
+                defaultLeaderboardSettings.isAutoExpandPreSelectedRace(),
+                defaultLeaderboardSettings.getDelayBetweenAutoAdvancesInMilliseconds(),
+                leaderboardSettings.getNameOfRaceToSort(), leaderboardSettings.isSortAscending(),
+                defaultLeaderboardSettings.isUpdateUponPlayStateChange(),
+                defaultLeaderboardSettings.getActiveRaceColumnSelectionStrategy(),
+                defaultLeaderboardSettings.isShowAddedScores(),
+                defaultLeaderboardSettings.isShowOverallColumnWithNumberOfRacesCompletedPerCompetitor(),
+                defaultLeaderboardSettings.isShowCompetitorSailIdColumn(),
+                defaultLeaderboardSettings.isShowCompetitorFullNameColumn());
+        contextSpecificLeaderboardSettings = LeaderboardSettingsFactory.getInstance().keepDefaults(leaderboardSettings,
+                contextSpecificLeaderboardSettings);
+
+        Map<String, Settings> clonedComponentIdsAndSettings = rootLifecycle
+                .cloneComponentIdsAndSettings(defaultSettings);
+        clonedComponentIdsAndSettings.put(leaderboardComponentId, contextSpecificLeaderboardSettings);
+        return new PerspectiveCompositeSettings<LeaderboardPerspectiveOwnSettings>(
+                defaultSettings.getPerspectiveOwnSettings(), clonedComponentIdsAndSettings);
+    }
+
+    @Override
+    protected PerspectiveCompositeSettings<LeaderboardPerspectiveOwnSettings> extractGlobalSettings(
+            PerspectiveCompositeSettings<LeaderboardPerspectiveOwnSettings> newRootSettings) {
+        // TODO extract common logic (copied from RaceBoard)
+        String leaderboardComponentId = rootLifecycle.getLeaderboardPanelLifecycle().getComponentId();
+        LeaderboardSettings currentLeaderboardSettings = (LeaderboardSettings) newRootSettings
+                .getSettingsPerComponentId().get(leaderboardComponentId);
+        LeaderboardSettings defaultLeaderboardSettings = currentLeaderboardSettings.getDefaultSettings();
+        LeaderboardSettings globalLeaderboardSettings = new LeaderboardSettings(
+                currentLeaderboardSettings.getManeuverDetailsToShow(), currentLeaderboardSettings.getLegDetailsToShow(),
+                currentLeaderboardSettings.getRaceDetailsToShow(), currentLeaderboardSettings.getOverallDetailsToShow(),
+                defaultLeaderboardSettings.getNamesOfRaceColumnsToShow(),
+                defaultLeaderboardSettings.getNamesOfRacesToShow(),
+                currentLeaderboardSettings.getNumberOfLastRacesToShow(),
+                defaultLeaderboardSettings.isAutoExpandPreSelectedRace(),
+                currentLeaderboardSettings.getDelayBetweenAutoAdvancesInMilliseconds(),
+                defaultLeaderboardSettings.getNameOfRaceToSort(), defaultLeaderboardSettings.isSortAscending(),
+                currentLeaderboardSettings.isUpdateUponPlayStateChange(),
+                currentLeaderboardSettings.getActiveRaceColumnSelectionStrategy(),
+                currentLeaderboardSettings.isShowAddedScores(),
+                currentLeaderboardSettings.isShowOverallColumnWithNumberOfRacesCompletedPerCompetitor(),
+                currentLeaderboardSettings.isShowCompetitorSailIdColumn(),
+                currentLeaderboardSettings.isShowCompetitorFullNameColumn());
+        globalLeaderboardSettings = LeaderboardSettingsFactory.getInstance().keepDefaults(currentLeaderboardSettings,
+                globalLeaderboardSettings);
+        Map<String, Settings> clonedComponentIdsAndSettings = rootLifecycle
+                .cloneComponentIdsAndSettings(newRootSettings);
+        clonedComponentIdsAndSettings.put(leaderboardComponentId, globalLeaderboardSettings);
+        return new PerspectiveCompositeSettings<LeaderboardPerspectiveOwnSettings>(
+                newRootSettings.getPerspectiveOwnSettings(), clonedComponentIdsAndSettings);
+    }
+}

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/leaderboard/AbstractLeaderboardPerspectiveLifecycle.java

@@ -0,0 +1,56 @@
+package com.sap.sailing.gwt.ui.leaderboard;
+
+import com.sap.sailing.gwt.ui.client.StringMessages;
+import com.sap.sse.gwt.client.shared.components.SettingsDialogComponent;
+import com.sap.sse.gwt.client.shared.perspective.AbstractPerspectiveLifecycle;
+
+public abstract class AbstractLeaderboardPerspectiveLifecycle extends AbstractPerspectiveLifecycle<LeaderboardPerspectiveOwnSettings> {
+
+    private final LeaderboardPanelLifecycle leaderboardPanelLifecycle;
+
+    public AbstractLeaderboardPerspectiveLifecycle(StringMessages stringMessages) {
+        leaderboardPanelLifecycle = new LeaderboardPanelLifecycle(null, stringMessages);
+        componentLifecycles.add(leaderboardPanelLifecycle);
+    }
+    
+    @Override
+    public LeaderboardPerspectiveOwnSettings createPerspectiveOwnDefaultSettings() {
+        return new LeaderboardPerspectiveOwnSettings();
+    }
+    
+    public LeaderboardPanelLifecycle getLeaderboardPanelLifecycle() {
+        return leaderboardPanelLifecycle;
+    }
+
+    @Override
+    public LeaderboardPerspectiveOwnSettings clonePerspectiveOwnSettings(LeaderboardPerspectiveOwnSettings settings) {
+        // TODO Auto-generated method stub
+        return settings;
+    }
+
+    @Override
+    public SettingsDialogComponent<LeaderboardPerspectiveOwnSettings> getPerspectiveOwnSettingsDialogComponent(
+            LeaderboardPerspectiveOwnSettings settings) {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+    @Override
+    public String getLocalizedShortName() {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+    @Override
+    public String getComponentId() {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+    @Override
+    public boolean hasSettings() {
+        // TODO Auto-generated method stub
+        return false;
+    }
+
+}

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/leaderboard/AbstractLeaderboardViewer.java

@@ -10,7 +10,6 @@ import com.google.gwt.event.logical.shared.ValueChangeHandler;
 import com.google.gwt.user.client.ui.Button;
 import com.google.gwt.user.client.ui.CheckBox;
 import com.google.gwt.user.client.ui.FlowPanel;
-import com.google.gwt.user.client.ui.SimplePanel;
 import com.sap.sailing.gwt.ui.client.CompetitorSelectionModel;
 import com.sap.sailing.gwt.ui.client.DebugIdHelper;
 import com.sap.sailing.gwt.ui.client.StringMessages;
@@ -20,13 +19,16 @@ import com.sap.sse.gwt.client.player.TimeListener;
 import com.sap.sse.gwt.client.player.Timer;
 import com.sap.sse.gwt.client.shared.components.Component;
 import com.sap.sse.gwt.client.shared.components.SettingsDialog;
+import com.sap.sse.gwt.client.shared.components.SettingsDialogComponent;
+import com.sap.sse.gwt.client.shared.perspective.AbstractPerspectiveComposite;
+import com.sap.sse.gwt.client.shared.perspective.PerspectiveLifecycleWithAllSettings;
 
 /**
  * A base class for a leaderboard viewer.
  * 
  * @author Frank Mittag (c163874)
  */
-public abstract class AbstractLeaderboardViewer extends SimplePanel {
+public abstract class AbstractLeaderboardViewer<PL extends AbstractLeaderboardPerspectiveLifecycle> extends AbstractPerspectiveComposite<PL, LeaderboardPerspectiveOwnSettings> {
     
     protected static final ViewerToolbar RES = GWT.create(ViewerToolbar.class);
     protected final StringMessages stringMessages;
@@ -40,14 +42,19 @@ public abstract class AbstractLeaderboardViewer extends SimplePanel {
     protected final boolean hideToolbar;
 
 
-    public AbstractLeaderboardViewer(CompetitorSelectionModel competitorSelectionProvider, AsyncActionsExecutor asyncActionsExecutor,
-            Timer timer, StringMessages stringMessages, boolean hideToolbar, LeaderboardPanel leaderboardPanel) {
+    public AbstractLeaderboardViewer(AbstractLeaderboardComponentContext<PL> componentContext,
+            PerspectiveLifecycleWithAllSettings<PL, LeaderboardPerspectiveOwnSettings> perspectiveLifecycleWithAllSettings,
+            CompetitorSelectionModel competitorSelectionProvider, AsyncActionsExecutor asyncActionsExecutor,
+            Timer timer, StringMessages stringMessages, LeaderboardPanel leaderboardPanel) {
+        super(componentContext, perspectiveLifecycleWithAllSettings);
+        addChildComponent(leaderboardPanel);
+        
         this.competitorSelectionProvider = competitorSelectionProvider;
         this.leaderboardPanel = leaderboardPanel;
         this.asyncActionsExecutor = asyncActionsExecutor;
         this.stringMessages = stringMessages;
         this.timer = timer;
-        this.hideToolbar = hideToolbar;
+        this.hideToolbar = perspectiveLifecycleWithAllSettings.getPerspectiveSettings().isHideToolbar();
         
         RES.css().ensureInjected();
     }
@@ -59,12 +66,13 @@ public abstract class AbstractLeaderboardViewer extends SimplePanel {
     protected FlowPanel createViewerPanel() {
         FlowPanel mainPanel = new FlowPanel();
         mainPanel.setSize("100%", "100%");
-        getElement().getStyle().setMarginLeft(12, Unit.PX);
-        getElement().getStyle().setMarginRight(12, Unit.PX);
+        mainPanel.getElement().getStyle().setMarginLeft(12, Unit.PX);
+        mainPanel.getElement().getStyle().setMarginRight(12, Unit.PX);
         if (!hideToolbar) {
             componentsNavigationPanel = new FlowPanel();
             componentsNavigationPanel.addStyleName(RES.css().viewerToolbar());
             mainPanel.add(componentsNavigationPanel);
+            addChildComponent(leaderboardPanel);
         }
         return mainPanel;
     }
@@ -117,5 +125,29 @@ public abstract class AbstractLeaderboardViewer extends SimplePanel {
         }
     }
 
+
+    @Override
+    public SettingsDialogComponent<LeaderboardPerspectiveOwnSettings> getPerspectiveOwnSettingsDialogComponent() {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+    @Override
+    public boolean hasPerspectiveOwnSettings() {
+        // TODO Auto-generated method stub
+        return true;
+    }
+
+    @Override
+    public String getId() {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+    @Override
+    public String getDependentCssClassName() {
+        // TODO Auto-generated method stub
+        return null;
+    }
 }
 

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/leaderboard/LeaderboardComponentContext.java

@@ -0,0 +1,12 @@
+package com.sap.sailing.gwt.ui.leaderboard;
+
+import com.sap.sse.gwt.client.shared.perspective.PerspectiveCompositeSettings;
+import com.sap.sse.gwt.client.shared.perspective.SettingsStorageManager;
+
+public class LeaderboardComponentContext extends AbstractLeaderboardComponentContext<LeaderboardPerspectiveLifecycle> {
+
+    public LeaderboardComponentContext(LeaderboardPerspectiveLifecycle rootLifecycle,
+            SettingsStorageManager<PerspectiveCompositeSettings<LeaderboardPerspectiveOwnSettings>> settingsStorageManager) {
+        super(rootLifecycle, settingsStorageManager);
+    }
+}

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/leaderboard/LeaderboardContextSettings.java

@@ -0,0 +1,58 @@
+package com.sap.sailing.gwt.ui.leaderboard;
+
+import java.util.UUID;
+
+import com.sap.sse.common.settings.generic.AbstractGenericSerializableSettings;
+import com.sap.sse.common.settings.generic.BooleanSetting;
+import com.sap.sse.common.settings.generic.StringSetting;
+import com.sap.sse.common.settings.generic.UUIDSetting;
+
+public class LeaderboardContextSettings extends AbstractGenericSerializableSettings {
+    private static final long serialVersionUID = 6699950643747065960L;
+    
+    private transient BooleanSetting embedded;
+    private transient UUIDSetting eventId;
+    private transient StringSetting leaderboardName;
+    private transient StringSetting leaderboardGroupName;
+    private transient StringSetting displayName;
+    private transient StringSetting zoomTo;
+    private transient StringSetting raceName;
+    private transient StringSetting regattaName;
+    @Override
+    protected void addChildSettings() {
+        embedded = new BooleanSetting(LeaderboardUrlSettings.PARAM_EMBEDDED, this, false);
+        eventId = new UUIDSetting(LeaderboardUrlSettings.PARAM_EVENT_ID, this);
+        leaderboardName = new StringSetting("name", this);
+        leaderboardGroupName = new StringSetting(LeaderboardUrlSettings.PARAM_LEADERBOARD_GROUP_NAME, this);
+        displayName = new StringSetting("displayName", this);
+        zoomTo = new StringSetting(LeaderboardUrlSettings.PARAM_ZOOM_TO, this);
+        raceName = new StringSetting(LeaderboardUrlSettings.PARAM_RACE_NAME, this);
+        regattaName = new StringSetting(LeaderboardUrlSettings.PARAM_REGATTA_NAME, this);
+    }
+    public boolean getEmbedded() {
+        return embedded.getValue();
+    }
+    public UUID getEventId() {
+        return eventId.getValue();
+    }
+    public String getLeaderboardName() {
+        return leaderboardName.getValue();
+    }
+    public String getLeaderboardGroupName() {
+        return leaderboardGroupName.getValue();
+    }
+    public String getDisplayName() {
+        return displayName.getValue();
+    }
+    public String getZoomTo() {
+        return zoomTo.getValue();
+    }
+    public String getRaceName() {
+        return raceName.getValue();
+    }
+    public String getRegattaName() {
+        return regattaName.getValue();
+    }
+    
+    
+}

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/leaderboard/LeaderboardEntryPoint.java

@@ -15,7 +15,6 @@ import com.google.gwt.user.client.ui.Label;
 import com.google.gwt.user.client.ui.RootLayoutPanel;
 import com.google.gwt.user.client.ui.RootPanel;
 import com.google.gwt.user.client.ui.ScrollPanel;
-import com.google.gwt.user.client.ui.Widget;
 import com.sap.sailing.domain.common.DetailType;
 import com.sap.sailing.domain.common.LeaderboardType;
 import com.sap.sailing.domain.common.RegattaAndRaceIdentifier;
@@ -34,13 +33,20 @@ import com.sap.sse.gwt.client.dialog.DataEntryDialog;
 import com.sap.sse.gwt.client.player.Timer;
 import com.sap.sse.gwt.client.player.Timer.PlayModes;
 import com.sap.sse.gwt.client.player.Timer.PlayStates;
+import com.sap.sse.gwt.client.shared.perspective.OnSettingsLoadedCallback;
+import com.sap.sse.gwt.client.shared.perspective.PerspectiveCompositeSettings;
+import com.sap.sse.gwt.client.shared.perspective.PerspectiveLifecycleWithAllSettings;
+import com.sap.sse.gwt.settings.SettingsToUrlSerializer;
 import com.sap.sse.gwt.shared.GwtHttpRequestUtils;
+import com.sap.sse.security.ui.settings.UserSettingsStorageManager;
 
 
 public class LeaderboardEntryPoint extends AbstractSailingEntryPoint {
     public static final long DEFAULT_REFRESH_INTERVAL_MILLIS = 3000l;
 
     private static final Logger logger = Logger.getLogger(LeaderboardEntryPoint.class.getName());
+    
+    private final SettingsToUrlSerializer settingsToUrlSerializer = new SettingsToUrlSerializer();
 
     private String leaderboardName;
     private String leaderboardGroupName;
@@ -50,14 +56,12 @@ public class LeaderboardEntryPoint extends AbstractSailingEntryPoint {
     @Override
     protected void doOnModuleLoad() {
         super.doOnModuleLoad();
-        final boolean showRaceDetails = GwtHttpRequestUtils.getBooleanParameter(LeaderboardUrlSettings.PARAM_SHOW_RACE_DETAILS, false /* default*/);
-        final boolean embedded = GwtHttpRequestUtils.getBooleanParameter(LeaderboardUrlSettings.PARAM_EMBEDDED, false /* default*/); 
-        final boolean hideToolbar = GwtHttpRequestUtils.getBooleanParameter(LeaderboardUrlSettings.PARAM_HIDE_TOOLBAR, false /* default*/); 
-        final String eventIdAsString = GwtHttpRequestUtils.getStringParameter(LeaderboardUrlSettings.PARAM_EVENT_ID, null /* default*/);
-        final UUID eventId = eventIdAsString == null ? null : UUID.fromString(eventIdAsString);
+        final LeaderboardContextSettings leaderboardContextSettings = settingsToUrlSerializer.deserializeFromCurrentLocation(new LeaderboardContextSettings());
+        
+        final UUID eventId = leaderboardContextSettings.getEventId();
 
-        leaderboardName = Window.Location.getParameter("name");
-        leaderboardGroupName = Window.Location.getParameter(LeaderboardUrlSettings.PARAM_LEADERBOARD_GROUP_NAME);
+        leaderboardName = leaderboardContextSettings.getLeaderboardName();
+        leaderboardGroupName = leaderboardContextSettings.getLeaderboardGroupName();
 
         if (leaderboardName != null) {
             final Runnable checkLeaderboardNameAndCreateUI = new Runnable() {
@@ -72,7 +76,7 @@ public class LeaderboardEntryPoint extends AbstractSailingEntryPoint {
                                                     && leaderboardName.equals(leaderboardNameAndType.getA())) {
                                                 Window.setTitle(leaderboardName);
                                                 leaderboardType = leaderboardNameAndType.getB();
-                                                createUI(showRaceDetails, embedded, hideToolbar, event);
+                                                createUI(leaderboardContextSettings, event);
                                             } else {
                                                 RootPanel.get().add(new Label(getStringMessages().noSuchLeaderboard()));
                                             }
@@ -106,7 +110,7 @@ public class LeaderboardEntryPoint extends AbstractSailingEntryPoint {
         } else {
             RootPanel.get().add(new Label(getStringMessages().noSuchLeaderboard()));
         }
-        final String zoomTo = Window.Location.getParameter(LeaderboardUrlSettings.PARAM_ZOOM_TO);
+        final String zoomTo = leaderboardContextSettings.getZoomTo();
         if (zoomTo != null) {
             RootPanel.getBodyElement().setAttribute(
                     "style",
@@ -117,12 +121,12 @@ public class LeaderboardEntryPoint extends AbstractSailingEntryPoint {
         }
     }
     
-    private void createUI(boolean showRaceDetails, boolean embedded, boolean hideToolbar, EventDTO event) {
+    private void createUI(LeaderboardContextSettings leaderboardContextSettings, EventDTO event) {
         DockLayoutPanel mainPanel = new DockLayoutPanel(Unit.PX);
         RootLayoutPanel.get().add(mainPanel);
-        if (!embedded) {
+        if (!leaderboardContextSettings.getEmbedded()) {
             // Hack to shorten the leaderboardName in case of overall leaderboards
-            String leaderboardDisplayName = Window.Location.getParameter("displayName");
+            String leaderboardDisplayName = leaderboardContextSettings.getDisplayName();
             if (leaderboardDisplayName == null || leaderboardDisplayName.isEmpty()) {
                 leaderboardDisplayName = leaderboardName;
             }
@@ -132,17 +136,11 @@ public class LeaderboardEntryPoint extends AbstractSailingEntryPoint {
         }
         ScrollPanel contentScrollPanel = new ScrollPanel();
         long delayBetweenAutoAdvancesInMilliseconds = DEFAULT_REFRESH_INTERVAL_MILLIS;
-        final RegattaAndRaceIdentifier preselectedRace = getPreselectedRace(Window.Location.getParameterMap());
-        // make a single live request as the default but don't continue to play by default
         Timer timer = new Timer(PlayModes.Live, PlayStates.Paused, delayBetweenAutoAdvancesInMilliseconds);
         final LeaderboardSettings leaderboardSettings = createLeaderboardSettingsFromURLParameters(Window.Location.getParameterMap());
         if (leaderboardSettings.getDelayBetweenAutoAdvancesInMilliseconds() != null) {
             timer.setPlayMode(PlayModes.Live); // the leaderboard, viewed via the entry point, goes "live" and "playing" if an auto-refresh
         } // interval has been specified
-        boolean autoExpandLastRaceColumn = GwtHttpRequestUtils.getBooleanParameter(LeaderboardUrlSettings.PARAM_AUTO_EXPAND_LAST_RACE_COLUMN, false);
-        boolean showCharts = GwtHttpRequestUtils.getBooleanParameter(LeaderboardUrlSettings.PARAM_SHOW_CHARTS, false);
-        boolean showOverallLeaderboard = GwtHttpRequestUtils.getBooleanParameter(LeaderboardUrlSettings.PARAM_SHOW_OVERALL_LEADERBOARD, false);
-        boolean showSeriesLeaderboards = GwtHttpRequestUtils.getBooleanParameter(LeaderboardUrlSettings.PARAM_SHOW_SERIES_LEADERBOARDS, false);
         String chartDetailParam = GwtHttpRequestUtils.getStringParameter(LeaderboardUrlSettings.PARAM_CHART_DETAIL, null);
         final DetailType chartDetailType;
         if (chartDetailParam != null && (DetailType.REGATTA_RANK.name().equals(chartDetailParam) || DetailType.OVERALL_RANK.name().equals(chartDetailParam) || 
@@ -151,18 +149,52 @@ public class LeaderboardEntryPoint extends AbstractSailingEntryPoint {
         } else {
             chartDetailType = leaderboardType.isMetaLeaderboard() ?  DetailType.OVERALL_RANK : DetailType.REGATTA_RANK;
         }
+
+        final RegattaAndRaceIdentifier preselectedRace = getPreselectedRace(Window.Location.getParameterMap());
+        // make a single live request as the default but don't continue to play by default
         
-        final Widget leaderboardViewer;
         if (leaderboardType.isMetaLeaderboard()) {
-            leaderboardViewer = new MetaLeaderboardViewer(sailingService, new AsyncActionsExecutor(),
-                    timer, leaderboardSettings, null, preselectedRace, leaderboardGroupName, leaderboardName, this, getStringMessages(),
-                    userAgent, showRaceDetails, hideToolbar, autoExpandLastRaceColumn, showCharts, chartDetailType, showSeriesLeaderboards);
+            final MetaLeaderboardPerspectiveLifecycle lifecycle = new MetaLeaderboardPerspectiveLifecycle(getStringMessages());
+            final MetaLeaderboardComponentContext componentContext = new MetaLeaderboardComponentContext(lifecycle, new UserSettingsStorageManager<>(getUserService(), "TODO1", "TODO2"));
+            componentContext.initInitialSettings(new OnSettingsLoadedCallback<PerspectiveCompositeSettings<LeaderboardPerspectiveOwnSettings>>() {
+                @Override
+                public void onSuccess(PerspectiveCompositeSettings<LeaderboardPerspectiveOwnSettings> defaultSettings) {
+                    PerspectiveLifecycleWithAllSettings<MetaLeaderboardPerspectiveLifecycle, LeaderboardPerspectiveOwnSettings> lifecycleWithAllSettings = new PerspectiveLifecycleWithAllSettings<>(lifecycle, defaultSettings);
+                    MetaLeaderboardViewer leaderboardViewer = new MetaLeaderboardViewer(componentContext, lifecycleWithAllSettings, sailingService, new AsyncActionsExecutor(),
+                    timer, null, preselectedRace, leaderboardGroupName, leaderboardName, LeaderboardEntryPoint.this, getStringMessages(),
+                    userAgent, chartDetailType);
+                    contentScrollPanel.setWidget(leaderboardViewer);
+                }
+                
+                @Override
+                public void onError(Throwable caught,
+                        PerspectiveCompositeSettings<LeaderboardPerspectiveOwnSettings> fallbackDefaultSettings) {
+                    // TODO
+                    onSuccess(fallbackDefaultSettings);
+                }
+            });
         } else {
-            leaderboardViewer = new LeaderboardViewer(sailingService, new AsyncActionsExecutor(),
-                    timer, leaderboardSettings, preselectedRace, leaderboardGroupName, leaderboardName, this, getStringMessages(),
-                    userAgent, showRaceDetails, hideToolbar, autoExpandLastRaceColumn, showCharts, chartDetailType, showOverallLeaderboard);
+            final LeaderboardPerspectiveLifecycle lifecycle = new LeaderboardPerspectiveLifecycle(getStringMessages());
+            final LeaderboardComponentContext componentContext = new LeaderboardComponentContext(lifecycle, new UserSettingsStorageManager<>(getUserService(), "TODO3", "TODO4"));
+            componentContext.initInitialSettings(new OnSettingsLoadedCallback<PerspectiveCompositeSettings<LeaderboardPerspectiveOwnSettings>>() {
+                @Override
+                public void onSuccess(PerspectiveCompositeSettings<LeaderboardPerspectiveOwnSettings> defaultSettings) {
+                    PerspectiveLifecycleWithAllSettings<LeaderboardPerspectiveLifecycle, LeaderboardPerspectiveOwnSettings> lifecycleWithAllSettings = new PerspectiveLifecycleWithAllSettings<>(lifecycle, defaultSettings);
+                    LeaderboardViewer leaderboardViewer = new LeaderboardViewer(
+                            componentContext, lifecycleWithAllSettings, sailingService, new AsyncActionsExecutor(),
+                            timer, preselectedRace, leaderboardGroupName, leaderboardName, LeaderboardEntryPoint.this, getStringMessages(),
+                            userAgent, chartDetailType);
+                    contentScrollPanel.setWidget(leaderboardViewer);
+                }
+                
+                @Override
+                public void onError(Throwable caught,
+                        PerspectiveCompositeSettings<LeaderboardPerspectiveOwnSettings> fallbackDefaultSettings) {
+                    // TODO
+                    onSuccess(fallbackDefaultSettings);
+                }
+            });
         }
-        contentScrollPanel.setWidget(leaderboardViewer);
         mainPanel.add(contentScrollPanel);
     }
    

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/leaderboard/LeaderboardPanel.java

@@ -3357,7 +3357,7 @@ public class LeaderboardPanel extends AbstractCompositeComponent<LeaderboardSett
 
     @Override
     public String getId() {
-        return "LeaderboardPanel";
+        return LeaderboardPanelLifecycle.ID;
     }
 
 }

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/leaderboard/LeaderboardPanelLifecycle.java

@@ -9,6 +9,8 @@ import com.sap.sailing.gwt.ui.client.StringMessages;
 import com.sap.sse.gwt.client.shared.components.ComponentLifecycle;
 
 public class LeaderboardPanelLifecycle implements ComponentLifecycle<LeaderboardSettings, LeaderboardSettingsDialogComponent> {
+    protected static final String ID = "LeaderboardPanel";
+    
     private final StringMessages stringMessages;
     private final List<RaceColumnDTO> raceList;
 
@@ -44,7 +46,7 @@ public class LeaderboardPanelLifecycle implements ComponentLifecycle<Leaderboard
 
     @Override
     public String getComponentId() {
-        return "LeaderboardPanel";
+        return ID;
     }
 
     @Override

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/leaderboard/LeaderboardPerspectiveLifecycle.java

@@ -0,0 +1,11 @@
+package com.sap.sailing.gwt.ui.leaderboard;
+
+import com.sap.sailing.gwt.ui.client.StringMessages;
+
+public class LeaderboardPerspectiveLifecycle extends AbstractLeaderboardPerspectiveLifecycle {
+
+    public LeaderboardPerspectiveLifecycle(StringMessages stringMessages) {
+        super(stringMessages);
+    }
+
+}

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/leaderboard/LeaderboardPerspectiveOwnSettings.java

@@ -0,0 +1,44 @@
+package com.sap.sailing.gwt.ui.leaderboard;
+
+import com.sap.sse.common.settings.generic.AbstractGenericSerializableSettings;
+import com.sap.sse.common.settings.generic.BooleanSetting;
+
+public class LeaderboardPerspectiveOwnSettings extends AbstractGenericSerializableSettings {
+    private static final long serialVersionUID = 8978956250485028963L;
+    
+    private transient BooleanSetting showRaceDetails;
+    private transient BooleanSetting hideToolbar;
+    private transient BooleanSetting autoExpandLastRaceColumn;
+    private transient BooleanSetting showCharts;
+    private transient BooleanSetting showOverallLeaderboard;
+    private transient BooleanSetting showSeriesLeaderboards;
+    
+    @Override
+    protected void addChildSettings() {
+        showRaceDetails = new BooleanSetting(LeaderboardUrlSettings.PARAM_SHOW_RACE_DETAILS, this, false);
+        hideToolbar = new BooleanSetting(LeaderboardUrlSettings.PARAM_HIDE_TOOLBAR, this, false);
+        autoExpandLastRaceColumn = new BooleanSetting(LeaderboardUrlSettings.PARAM_AUTO_EXPAND_LAST_RACE_COLUMN, this, false);
+        showCharts = new BooleanSetting(LeaderboardUrlSettings.PARAM_SHOW_CHARTS, this, false);
+        showOverallLeaderboard = new BooleanSetting(LeaderboardUrlSettings.PARAM_SHOW_OVERALL_LEADERBOARD, this, false);
+        showSeriesLeaderboards = new BooleanSetting(LeaderboardUrlSettings.PARAM_SHOW_SERIES_LEADERBOARDS, this, false);
+    }
+    public boolean isShowRaceDetails() {
+        return showRaceDetails.getValue();
+    }
+    public boolean isHideToolbar() {
+        return hideToolbar.getValue();
+    }
+    public boolean isAutoExpandLastRaceColumn() {
+        return autoExpandLastRaceColumn.getValue();
+    }
+    public boolean isShowCharts() {
+        return showCharts.getValue();
+    }
+    public boolean isShowOverallLeaderboard() {
+        return showOverallLeaderboard.getValue();
+    }
+    public boolean isShowSeriesLeaderboards() {
+        return showSeriesLeaderboards.getValue();
+    }
+    
+}

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/leaderboard/LeaderboardViewer.java

@@ -15,6 +15,7 @@ import com.sap.sse.gwt.client.ErrorReporter;
 import com.sap.sse.gwt.client.async.AsyncActionsExecutor;
 import com.sap.sse.gwt.client.async.MarkedAsyncCallback;
 import com.sap.sse.gwt.client.player.Timer;
+import com.sap.sse.gwt.client.shared.perspective.PerspectiveLifecycleWithAllSettings;
 import com.sap.sse.gwt.client.useragent.UserAgentDetails;
 
 /**
@@ -22,36 +23,41 @@ import com.sap.sse.gwt.client.useragent.UserAgentDetails;
  * @author Frank Mittag (c163874)
  *
  */
-public class LeaderboardViewer extends AbstractLeaderboardViewer {
+public class LeaderboardViewer extends AbstractLeaderboardViewer<LeaderboardPerspectiveLifecycle> {
     private final MultiCompetitorLeaderboardChart multiCompetitorChart;
     private LeaderboardPanel overallLeaderboardPanel;
     
-    public LeaderboardViewer(final SailingServiceAsync sailingService, final AsyncActionsExecutor asyncActionsExecutor,
-            final Timer timer, final LeaderboardSettings leaderboardSettings, final RegattaAndRaceIdentifier preselectedRace,
+    public LeaderboardViewer(LeaderboardComponentContext componentContext,
+            PerspectiveLifecycleWithAllSettings<LeaderboardPerspectiveLifecycle, LeaderboardPerspectiveOwnSettings> perspectiveLifecycleWithAllSettings,
+            final SailingServiceAsync sailingService, final AsyncActionsExecutor asyncActionsExecutor,
+            final Timer timer, final RegattaAndRaceIdentifier preselectedRace,
             final String leaderboardGroupName, String leaderboardName, final ErrorReporter errorReporter,
-            final StringMessages stringMessages, final UserAgentDetails userAgent, boolean showRaceDetails, boolean hideToolbar, 
-            boolean autoExpandLastRaceColumn, boolean showCharts, DetailType chartDetailType, boolean showOverallLeaderboard) {
-        this(new CompetitorSelectionModel(/* hasMultiSelection */true), sailingService, asyncActionsExecutor, timer,
-                leaderboardSettings, preselectedRace, leaderboardGroupName, leaderboardName, errorReporter,
-                stringMessages, userAgent, showRaceDetails, hideToolbar, autoExpandLastRaceColumn, showCharts,
-                chartDetailType, showOverallLeaderboard);
+            final StringMessages stringMessages, final UserAgentDetails userAgent, DetailType chartDetailType) {
+        this(componentContext, perspectiveLifecycleWithAllSettings, new CompetitorSelectionModel(/* hasMultiSelection */true), sailingService, asyncActionsExecutor, timer,
+                preselectedRace, leaderboardGroupName, leaderboardName, errorReporter,
+                stringMessages, userAgent, chartDetailType);
     }
 
-    private LeaderboardViewer(CompetitorSelectionModel competitorSelectionModel,
+    private LeaderboardViewer(LeaderboardComponentContext componentContext,
+            PerspectiveLifecycleWithAllSettings<LeaderboardPerspectiveLifecycle, LeaderboardPerspectiveOwnSettings> perspectiveLifecycleWithAllSettings,
+            CompetitorSelectionModel competitorSelectionModel,
             final SailingServiceAsync sailingService, final AsyncActionsExecutor asyncActionsExecutor,
-            final Timer timer, final LeaderboardSettings leaderboardSettings, final RegattaAndRaceIdentifier preselectedRace,
+            final Timer timer, final RegattaAndRaceIdentifier preselectedRace,
             final String leaderboardGroupName, String leaderboardName, final ErrorReporter errorReporter,
-            final StringMessages stringMessages, final UserAgentDetails userAgent, boolean showRaceDetails,
-            boolean hideToolbar, boolean autoExpandLastRaceColumn, boolean showCharts, DetailType chartDetailType,
-            boolean showOverallLeaderboard) {
-        super(competitorSelectionModel, asyncActionsExecutor, timer, stringMessages, hideToolbar, new LeaderboardPanel(
-                sailingService, asyncActionsExecutor, leaderboardSettings, preselectedRace != null, preselectedRace,
+            final StringMessages stringMessages, final UserAgentDetails userAgent, DetailType chartDetailType) {
+        super(componentContext, perspectiveLifecycleWithAllSettings, competitorSelectionModel, asyncActionsExecutor, timer, stringMessages, new LeaderboardPanel(
+                sailingService, asyncActionsExecutor, (LeaderboardSettings) perspectiveLifecycleWithAllSettings.getAllSettings().findSettingsByComponentId(LeaderboardPanelLifecycle.ID),
+                preselectedRace != null, preselectedRace,
                 competitorSelectionModel, timer, leaderboardGroupName, leaderboardName, errorReporter,
-                stringMessages, userAgent, showRaceDetails, /* competitorSearchTextBox */ null, /* showSelectionCheckbox */ true,
-                /* raceTimesInfoProvider */ null, autoExpandLastRaceColumn, /* adjustTimerDelay */ true, /* autoApplyTopNFilter */ false,
+                stringMessages, userAgent, perspectiveLifecycleWithAllSettings.getPerspectiveSettings().isShowRaceDetails(), /* competitorSearchTextBox */ null, /* showSelectionCheckbox */ true,
+                /* raceTimesInfoProvider */ null, perspectiveLifecycleWithAllSettings.getPerspectiveSettings().isAutoExpandLastRaceColumn(), /* adjustTimerDelay */ true, /* autoApplyTopNFilter */ false,
                 /* showCompetitorFilterStatus */ false, /* enableSyncScroller */ false));
+        
+        final LeaderboardPerspectiveOwnSettings perspectiveSettings = perspectiveLifecycleWithAllSettings.getPerspectiveSettings();
+        final boolean showCharts = perspectiveSettings.isShowCharts();
+        
         final FlowPanel mainPanel = createViewerPanel();
-        setWidget(mainPanel);
+        initWidget(mainPanel);
         multiCompetitorChart = new MultiCompetitorLeaderboardChart(sailingService, asyncActionsExecutor, leaderboardName, chartDetailType,
                 competitorSelectionProvider, timer, stringMessages, errorReporter);
         multiCompetitorChart.setVisible(showCharts); 
@@ -69,7 +75,7 @@ public class LeaderboardViewer extends AbstractLeaderboardViewer {
             multiCompetitorChart.timeChanged(timer.getTime(), null);
         }
         overallLeaderboardPanel = null;
-        if(showOverallLeaderboard) {
+        if(perspectiveSettings.isShowOverallLeaderboard()) {
             sailingService.getOverallLeaderboardNamesContaining(leaderboardName, new MarkedAsyncCallback<List<String>>(
                     new AsyncCallback<List<String>>() {
                         @Override
@@ -77,7 +83,7 @@ public class LeaderboardViewer extends AbstractLeaderboardViewer {
                             if(result.size() == 1) {
                                 String overallLeaderboardName = result.get(0);
                                 overallLeaderboardPanel = new LeaderboardPanel(sailingService, asyncActionsExecutor,
-                                        leaderboardSettings, preselectedRace != null, preselectedRace, competitorSelectionProvider, timer,
+                                        (LeaderboardSettings) perspectiveLifecycleWithAllSettings.getAllSettings().findSettingsByComponentId(LeaderboardPanelLifecycle.ID), preselectedRace != null, preselectedRace, competitorSelectionProvider, timer,
                                         leaderboardGroupName, overallLeaderboardName, errorReporter, stringMessages, userAgent,
                                         false, /* competitorSearchTextBox */ null, /* showSelectionCheckbox */ true,  /* raceTimesInfoProvider */null,
                                         false, /* adjustTimerDelay */ true, /* autoApplyTopNFilter */ false,

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/leaderboard/MetaLeaderboardComponentContext.java

@@ -0,0 +1,12 @@
+package com.sap.sailing.gwt.ui.leaderboard;
+
+import com.sap.sse.gwt.client.shared.perspective.PerspectiveCompositeSettings;
+import com.sap.sse.gwt.client.shared.perspective.SettingsStorageManager;
+
+public class MetaLeaderboardComponentContext extends AbstractLeaderboardComponentContext<MetaLeaderboardPerspectiveLifecycle> {
+
+    public MetaLeaderboardComponentContext(MetaLeaderboardPerspectiveLifecycle rootLifecycle,
+            SettingsStorageManager<PerspectiveCompositeSettings<LeaderboardPerspectiveOwnSettings>> settingsStorageManager) {
+        super(rootLifecycle, settingsStorageManager);
+    }
+}

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/leaderboard/MetaLeaderboardPerspectiveLifecycle.java

@@ -0,0 +1,11 @@
+package com.sap.sailing.gwt.ui.leaderboard;
+
+import com.sap.sailing.gwt.ui.client.StringMessages;
+
+public class MetaLeaderboardPerspectiveLifecycle extends AbstractLeaderboardPerspectiveLifecycle {
+
+    public MetaLeaderboardPerspectiveLifecycle(StringMessages stringMessages) {
+        super(stringMessages);
+    }
+
+}

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/leaderboard/MetaLeaderboardViewer.java

@@ -12,6 +12,7 @@ import com.sap.sailing.gwt.ui.client.shared.charts.MultiCompetitorLeaderboardCha
 import com.sap.sse.gwt.client.ErrorReporter;
 import com.sap.sse.gwt.client.async.AsyncActionsExecutor;
 import com.sap.sse.gwt.client.player.Timer;
+import com.sap.sse.gwt.client.shared.perspective.PerspectiveLifecycleWithAllSettings;
 import com.sap.sse.gwt.client.useragent.UserAgentDetails;
 
 /**
@@ -21,37 +22,43 @@ import com.sap.sse.gwt.client.useragent.UserAgentDetails;
  * @author Frank Mittag (c163874)
  * @author Axel Uhl (d043530)
  */
-public class MetaLeaderboardViewer extends AbstractLeaderboardViewer {    
+public class MetaLeaderboardViewer extends AbstractLeaderboardViewer<MetaLeaderboardPerspectiveLifecycle> {
     private final MultiLeaderboardPanel multiLeaderboardPanel;
     private final MultiCompetitorLeaderboardChart multiCompetitorChart;
 
     
-    public MetaLeaderboardViewer(SailingServiceAsync sailingService, AsyncActionsExecutor asyncActionsExecutor, 
-            Timer timer, LeaderboardSettings leaderboardSettings, String preselectedLeaderboardName, RegattaAndRaceIdentifier preselectedRace,
+    public MetaLeaderboardViewer(MetaLeaderboardComponentContext componentContext,
+            PerspectiveLifecycleWithAllSettings<MetaLeaderboardPerspectiveLifecycle, LeaderboardPerspectiveOwnSettings> perspectiveLifecycleWithAllSettings,
+            SailingServiceAsync sailingService, AsyncActionsExecutor asyncActionsExecutor, 
+            Timer timer, String preselectedLeaderboardName, RegattaAndRaceIdentifier preselectedRace,
             String leaderboardGroupName, String metaLeaderboardName, ErrorReporter errorReporter,
-            StringMessages stringMessages, UserAgentDetails userAgent, boolean showRaceDetails, boolean hideToolbar, 
-            boolean autoExpandLastRaceColumn, boolean showCharts, DetailType chartDetailType, boolean showSeriesLeaderboards) {
-        this(new CompetitorSelectionModel(/* hasMultiSelection */true), sailingService, asyncActionsExecutor,  timer,
-                leaderboardSettings, preselectedLeaderboardName, preselectedRace, leaderboardGroupName, metaLeaderboardName,
-                errorReporter, stringMessages, userAgent, showRaceDetails, hideToolbar,
-                autoExpandLastRaceColumn, showCharts, chartDetailType, showSeriesLeaderboards);
+            StringMessages stringMessages, UserAgentDetails userAgent, DetailType chartDetailType) {
+        this(componentContext, perspectiveLifecycleWithAllSettings, new CompetitorSelectionModel(/* hasMultiSelection */true), sailingService, asyncActionsExecutor,  timer,
+                preselectedLeaderboardName, preselectedRace, leaderboardGroupName, metaLeaderboardName,
+                errorReporter, stringMessages, userAgent, chartDetailType);
     }
     
-    private MetaLeaderboardViewer(CompetitorSelectionModel competitorSelectionModel, SailingServiceAsync sailingService,
-            AsyncActionsExecutor asyncActionsExecutor, Timer timer, LeaderboardSettings leaderboardSettings,
+    private MetaLeaderboardViewer(MetaLeaderboardComponentContext componentContext,
+            PerspectiveLifecycleWithAllSettings<MetaLeaderboardPerspectiveLifecycle, LeaderboardPerspectiveOwnSettings> perspectiveLifecycleWithAllSettings,
+            CompetitorSelectionModel competitorSelectionModel, SailingServiceAsync sailingService,
+            AsyncActionsExecutor asyncActionsExecutor, Timer timer,
             String preselectedLeaderboardName, RegattaAndRaceIdentifier preselectedRace, String leaderboardGroupName,
             String metaLeaderboardName, ErrorReporter errorReporter, StringMessages stringMessages,
-            UserAgentDetails userAgent, boolean showRaceDetails, boolean hideToolbar, boolean autoExpandLastRaceColumn,
-            boolean showCharts, DetailType chartDetailType, boolean showSeriesLeaderboards) {
-        super(competitorSelectionModel, asyncActionsExecutor,  timer, stringMessages, hideToolbar,
+            UserAgentDetails userAgent, DetailType chartDetailType) {
+        super(componentContext, perspectiveLifecycleWithAllSettings, competitorSelectionModel, asyncActionsExecutor,  timer, stringMessages,
                 new LeaderboardPanel(sailingService, asyncActionsExecutor,
-                        leaderboardSettings, preselectedRace != null, preselectedRace, competitorSelectionModel, timer,
+                        (LeaderboardSettings) perspectiveLifecycleWithAllSettings.getAllSettings().findSettingsByComponentId(LeaderboardPanelLifecycle.ID),
+                        preselectedRace != null, preselectedRace, competitorSelectionModel, timer,
                         leaderboardGroupName, metaLeaderboardName, errorReporter, stringMessages, userAgent,
-                        showRaceDetails, /* competitorSearchTextBox */ null, /* showSelectionCheckbox */ true,  /* raceTimesInfoProvider */null, 
-                        autoExpandLastRaceColumn, /* adjustTimerDelay */ true, /* autoApplyTopNFilter */ false,
+                        perspectiveLifecycleWithAllSettings.getPerspectiveSettings().isShowRaceDetails(), /* competitorSearchTextBox */ null, /* showSelectionCheckbox */ true,  /* raceTimesInfoProvider */null, 
+                        perspectiveLifecycleWithAllSettings.getPerspectiveSettings().isAutoExpandLastRaceColumn(), /* adjustTimerDelay */ true, /* autoApplyTopNFilter */ false,
                         /* showCompetitorFilterStatus */ false, /* enableSyncScroller */ false));
+        
+        final LeaderboardPerspectiveOwnSettings perspectiveSettings = perspectiveLifecycleWithAllSettings.getPerspectiveSettings();
+        final boolean showCharts = perspectiveSettings.isShowCharts();
+        
         FlowPanel mainPanel = createViewerPanel();
-        setWidget(mainPanel);
+        initWidget(mainPanel);
         final Label overallStandingsLabel = new Label(stringMessages.overallStandings());
         overallStandingsLabel.setStyleName("leaderboardHeading");
         multiCompetitorChart = new MultiCompetitorLeaderboardChart(sailingService, asyncActionsExecutor, metaLeaderboardName,
@@ -61,8 +68,8 @@ public class MetaLeaderboardViewer extends AbstractLeaderboardViewer {
         multiCompetitorChart.getElement().getStyle().setMarginBottom(10, Unit.PX);
         multiLeaderboardPanel = new MultiLeaderboardPanel(sailingService, metaLeaderboardName, asyncActionsExecutor, timer, false /*isEmbedded*/,
                 preselectedLeaderboardName, preselectedRace, errorReporter, stringMessages,
-                userAgent, showRaceDetails, autoExpandLastRaceColumn);
-        multiLeaderboardPanel.setVisible(showSeriesLeaderboards);
+                userAgent, perspectiveSettings.isShowRaceDetails(), perspectiveSettings.isAutoExpandLastRaceColumn());
+        multiLeaderboardPanel.setVisible(perspectiveSettings.isShowSeriesLeaderboards());
         mainPanel.add(getLeaderboardPanel());
         mainPanel.add(multiCompetitorChart);
         mainPanel.add(multiLeaderboardPanel);