Merge branch 'master' into bug3972

java/com.sap.sailing.domain.common/src/com/sap/sailing/domain/common/racelog/Flags.java

@@ -14,6 +14,7 @@ public enum Flags {
     INDIA,
     INDIA_ZULU, // the flag combination of I+Z flown at the same time
     NOVEMBER,
+    OSCAR,
     PAPA,
     UNIFORM,
     XRAY,

java/com.sap.sailing.domain.common/src/com/sap/sailing/domain/common/racelog/RacingProcedureType.java

@@ -11,6 +11,7 @@ import java.util.List;
 public enum RacingProcedureType {
     UNKNOWN("Unknown"),
     RRS26("Fix Line Start (RRS26)"),
+    SWC("Sailing World Cup Start"),
     GateStart("Gate Start"),
     ESS("\"Extreme Sailing Series\"-Start"),
     BASIC("Basic Countdown Start"),

java/com.sap.sailing.domain.shared.android/META-INF/MANIFEST.MF

@@ -26,8 +26,10 @@ Export-Package: com.sap.sailing.domain.abstractlog,
  com.sap.sailing.domain.abstractlog.race.state.racingprocedure.gate,
  com.sap.sailing.domain.abstractlog.race.state.racingprocedure.gate.impl,
  com.sap.sailing.domain.abstractlog.race.state.racingprocedure.impl,
- com.sap.sailing.domain.abstractlog.race.state.racingprocedure.rrs26,
- com.sap.sailing.domain.abstractlog.race.state.racingprocedure.rrs26.impl,
+ com.sap.sailing.domain.abstractlog.race.state.racingprocedure.league,
+ com.sap.sailing.domain.abstractlog.race.state.racingprocedure.league.impl,
+ com.sap.sailing.domain.abstractlog.race.state.racingprocedure.line,
+ com.sap.sailing.domain.abstractlog.race.state.racingprocedure.line.impl,
  com.sap.sailing.domain.abstractlog.race.tracking,
  com.sap.sailing.domain.abstractlog.race.tracking.analyzing.impl,
  com.sap.sailing.domain.abstractlog.race.tracking.impl,

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/abstractlog/race/analyzing/impl/SWCStartModeFlagFinder.java

@@ -0,0 +1,64 @@
+package com.sap.sailing.domain.abstractlog.race.analyzing.impl;
+
+import java.util.Arrays;
+import java.util.List;
+
+import com.sap.sailing.domain.abstractlog.race.RaceLog;
+import com.sap.sailing.domain.abstractlog.race.RaceLogEvent;
+import com.sap.sailing.domain.abstractlog.race.RaceLogFlagEvent;
+import com.sap.sailing.domain.common.racelog.Flags;
+import com.sap.sailing.domain.common.racelog.RacingProcedureType;
+
+public class SWCStartModeFlagFinder extends RaceLogAnalyzer<Flags> {
+
+    private final static List<Flags> defaultStartModeFlags = Arrays.asList(Flags.BLACK, Flags.UNIFORM);
+    
+    private final RacingProcedureTypeAnalyzer procedureAnalyzer;
+    private final List<Flags> startModeFlags;
+
+    /**
+     * Searches for the start mode flag of a SWC race.
+     * 
+     * @param procedureAnalyzer
+     *            to be used to ensure a SWC race. Must operate on the same race log. Otherwise a
+     *            {@link IllegalArgumentException} is thrown.
+     */
+    public SWCStartModeFlagFinder(RacingProcedureTypeAnalyzer procedureAnalyzer, RaceLog raceLog) {
+        this(procedureAnalyzer, raceLog, defaultStartModeFlags);
+    }
+    
+    public SWCStartModeFlagFinder(RacingProcedureTypeAnalyzer procedureAnalyzer, RaceLog raceLog, List<Flags> startModeFlags) {
+        super(raceLog);
+        if (raceLog != procedureAnalyzer.getLog()) {
+            throw new IllegalArgumentException("Both analyzers must operate on the same race log.");
+        }
+        this.procedureAnalyzer = procedureAnalyzer;
+        this.startModeFlags = startModeFlags;
+    }
+
+    @Override
+    protected Flags performAnalysis() {
+        RacingProcedureType type = procedureAnalyzer.analyze();
+        if (!RacingProcedureType.SWC.equals(type)) {
+            return null;
+        }
+        
+        for (RaceLogEvent event : getPassEventsDescending()) {
+            if (event instanceof RaceLogFlagEvent) {
+                RaceLogFlagEvent flagEvent = (RaceLogFlagEvent) event;
+                if (isStartModeFlagEvent(flagEvent)) {
+                    return flagEvent.getUpperFlag();
+                }
+            }
+        }
+        return null;
+    }
+    
+    private boolean isStartModeFlagEvent(RaceLogFlagEvent event) {
+        // no matter if displayed or removed
+        if (event.getLowerFlag().equals(Flags.NONE)) {
+            return startModeFlags.contains(event.getUpperFlag());
+        }
+        return false;
+    }
+}

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/abstractlog/race/state/impl/RaceStateEvents.java

@@ -8,7 +8,12 @@ public enum RaceStateEvents {
     RRS26_CLASS_UP,
     RRS26_STARTMODE_UP,
     RRS26_STARTMODE_DOWN,
-    
+
+    SWC_CLASS_OVER_OSCAR_UP,
+    SWC_STARTMODE_UP,
+    SWC_STARTMODE_DOWN,
+    SWC_CLASS_OVER_OSCAR_DOWN,
+
     ESS_AP_DOWN,
     ESS_THREE_UP,
     ESS_TWO_UP,

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/abstractlog/race/state/racingprocedure/RacingProcedurePrerequisite.java

@@ -2,7 +2,7 @@ package com.sap.sailing.domain.abstractlog.race.state.racingprocedure;
 
 import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.gate.impl.GateLaunchTimePrerequisite;
 import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.gate.impl.PathfinderPrerequisite;
-import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.rrs26.impl.StartmodePrerequisite;
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.line.impl.StartModePrerequisite;
 
 /**
  * Something that has to be fulfilled before the race can start (e.g. decide which start mode flag is shown).
@@ -24,7 +24,7 @@ public interface RacingProcedurePrerequisite {
 
         void fulfill(GateLaunchTimePrerequisite prerequisite);
 
-        void fulfill(StartmodePrerequisite prerequisite);
+        void fulfill(StartModePrerequisite prerequisite);
     }
 
     /**

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/abstractlog/race/state/racingprocedure/gate/impl/GateStartRacingProcedureImpl.java

@@ -33,7 +33,7 @@ import com.sap.sse.common.Util;
 
 public class GateStartRacingProcedureImpl extends BaseRacingProcedure implements GateStartRacingProcedure {
 
-    private final static long startPhaseClassOverGolfUpIntervall = 8 * 60 * 1000; // minutes * seconds * milliseconds
+    private final static long startPhaseClassOverGolfUpInterval = 8 * 60 * 1000; // minutes * seconds * milliseconds
     private final static long startPhasePapaUpInterval = 4 * 60 * 1000; // minutes * seconds * milliseconds
     private final static long startPhasePapaDownInterval = 1 * 60 * 1000; // minutes * seconds * milliseconds
 
@@ -99,7 +99,7 @@ public class GateStartRacingProcedureImpl extends BaseRacingProcedure implements
     public boolean isStartphaseActive(TimePoint startTime, TimePoint now) {
         if (now.before(startTime)) {
             long timeTillStart = startTime.minus(now.asMillis()).asMillis();
-            return timeTillStart < startPhaseClassOverGolfUpIntervall;
+            return timeTillStart < startPhaseClassOverGolfUpInterval;
         }
         return false;
     }
@@ -121,7 +121,7 @@ public class GateStartRacingProcedureImpl extends BaseRacingProcedure implements
     @Override
     protected Collection<RaceStateEvent> createStartStateEvents(TimePoint startTime) {
         return Arrays.<RaceStateEvent> asList(
-                new RaceStateEventImpl(startTime.minus(startPhaseClassOverGolfUpIntervall),
+                new RaceStateEventImpl(startTime.minus(startPhaseClassOverGolfUpInterval),
                         RaceStateEvents.GATE_CLASS_OVER_GOLF_UP),
                 new RaceStateEventImpl(startTime.minus(startPhasePapaUpInterval), RaceStateEvents.GATE_PAPA_UP),
                 new RaceStateEventImpl(startTime.minus(startPhasePapaDownInterval), RaceStateEvents.GATE_PAPA_DOWN),
@@ -153,13 +153,13 @@ public class GateStartRacingProcedureImpl extends BaseRacingProcedure implements
     public FlagPoleState getActiveFlags(TimePoint startTime, TimePoint now) {
         Flags classFlag = getConfiguration().getClassFlag() != null ? getConfiguration().getClassFlag() : Flags.CLASS;
         TimePoint gateShutdownTime = getGateShutdownTimePoint(startTime);
-        if (now.before(startTime.minus(startPhaseClassOverGolfUpIntervall))) {
+        if (now.before(startTime.minus(startPhaseClassOverGolfUpInterval))) {
             return new FlagPoleState(Arrays.asList(new FlagPole(classFlag, Flags.GOLF, false), new FlagPole(Flags.PAPA,
                     false)), null, Arrays.asList(new FlagPole(classFlag, Flags.GOLF, true), new FlagPole(Flags.PAPA,
-                    false)), startTime.minus(startPhaseClassOverGolfUpIntervall));
+                    false)), startTime.minus(startPhaseClassOverGolfUpInterval));
         } else if (now.before(startTime.minus(startPhasePapaUpInterval))) {
             return new FlagPoleState(Arrays.asList(new FlagPole(classFlag, Flags.GOLF, true), new FlagPole(Flags.PAPA,
-                    false)), startTime.minus(startPhaseClassOverGolfUpIntervall), Arrays.asList(new FlagPole(classFlag,
+                    false)), startTime.minus(startPhaseClassOverGolfUpInterval), Arrays.asList(new FlagPole(classFlag,
                     Flags.GOLF, true), new FlagPole(Flags.PAPA, true)), startTime.minus(startPhasePapaUpInterval));
         } else if (now.before(startTime.minus(startPhasePapaDownInterval))) {
             return new FlagPoleState(Arrays.asList(new FlagPole(classFlag, Flags.GOLF, true), new FlagPole(Flags.PAPA,

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/abstractlog/race/state/racingprocedure/impl/RacingProcedurePrerequisiteAutoResolver.java

@@ -4,7 +4,7 @@ import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.RacingProce
 import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.RacingProcedurePrerequisite.Resolver;
 import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.gate.impl.GateLaunchTimePrerequisite;
 import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.gate.impl.PathfinderPrerequisite;
-import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.rrs26.impl.StartmodePrerequisite;
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.line.impl.StartModePrerequisite;
 
 /**
  * Always calls {@link RacingProcedurePrerequisite#fulfillWithDefault()}.
@@ -22,13 +22,11 @@ public class RacingProcedurePrerequisiteAutoResolver implements Resolver {
     }
 
     @Override
-    public void fulfill(StartmodePrerequisite prerequisite) {
+    public void fulfill(StartModePrerequisite prerequisite) {
         prerequisite.fulfillWithDefault();
     }
 
     @Override
     public void onFulfilled() {
-        
     }
-
 }

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/abstractlog/race/state/racingprocedure/impl/ReadonlyRacingProcedureFactory.java

@@ -12,7 +12,8 @@ import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.basic.impl.
 import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.ess.impl.ESSRacingProcedureImpl;
 import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.gate.impl.GateStartRacingProcedureImpl;
 import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.league.impl.LeagueRacingProcedureImpl;
-import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.rrs26.impl.RRS26RacingProcedureImpl;
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.line.impl.RRS26RacingProcedureImpl;
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.line.impl.SWCRacingProcedureImpl;
 import com.sap.sailing.domain.base.configuration.ConfigurationLoader;
 import com.sap.sailing.domain.base.configuration.RegattaConfiguration;
 import com.sap.sailing.domain.common.racelog.RacingProcedureType;
@@ -47,6 +48,8 @@ public class ReadonlyRacingProcedureFactory implements RacingProcedureFactory {
                     loadedConfiguration.getGateStartConfiguration(), raceLogResolver);
         case RRS26:
             return new RRS26RacingProcedureImpl(raceLog, author, loadedConfiguration.getRRS26Configuration(), raceLogResolver);
+        case SWC:
+            return new SWCRacingProcedureImpl(raceLog, author, loadedConfiguration.getSWCConfiguration(), raceLogResolver);
         case BASIC:
             return new BasicRacingProcedureImpl(raceLog, author, loadedConfiguration.getBasicConfiguration(), raceLogResolver);
         case LEAGUE:

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/abstractlog/race/state/racingprocedure/line/ConfigurableStartModeFlagRacingProcedure.java

@@ -0,0 +1,25 @@
+package com.sap.sailing.domain.abstractlog.race.state.racingprocedure.line;
+
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.RacingProcedure;
+import com.sap.sailing.domain.base.configuration.procedures.ConfigurableStartModeFlagRacingProcedureConfiguration;
+import com.sap.sailing.domain.common.racelog.Flags;
+import com.sap.sse.common.TimePoint;
+
+/**
+ * A racing procedure for the typical line start as described in the 'Racing Rules of Sailing' (RRS)
+ * published by the World Sailing association.
+ * @author Frank
+ *
+ */
+public interface ConfigurableStartModeFlagRacingProcedure extends RacingProcedure  {
+
+    void addChangedListener(LineStartChangedListener listener);
+    
+    ConfigurableStartModeFlagRacingProcedureConfiguration getConfiguration();
+    
+    Flags getStartModeFlag();
+    
+    Flags getDefaultStartMode();
+    
+    void setStartModeFlag(TimePoint timePoint, Flags startMode);
+}

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/abstractlog/race/state/racingprocedure/line/LineStartChangedListener.java

@@ -0,0 +1,9 @@
+package com.sap.sailing.domain.abstractlog.race.state.racingprocedure.line;
+
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.RacingProcedureChangedListener;
+
+public interface LineStartChangedListener extends RacingProcedureChangedListener {
+    
+    void onStartModeChanged(ConfigurableStartModeFlagRacingProcedure racingProcedure);
+
+}

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/abstractlog/race/state/racingprocedure/line/RRS26RacingProcedure.java

@@ -1,17 +1,10 @@
-package com.sap.sailing.domain.abstractlog.race.state.racingprocedure.rrs26;
+package com.sap.sailing.domain.abstractlog.race.state.racingprocedure.line;
 
-import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.ReadonlyRacingProcedure;
 import com.sap.sailing.domain.base.configuration.procedures.RRS26Configuration;
 import com.sap.sailing.domain.common.racelog.Flags;
 
-public interface ReadonlyRRS26RacingProcedure extends ReadonlyRacingProcedure {
-    
+public interface RRS26RacingProcedure extends ConfigurableStartModeFlagRacingProcedure {
     public final static Flags DefaultStartMode = Flags.PAPA;
     
-    void addChangedListener(RRS26ChangedListener listener);
-    
     RRS26Configuration getConfiguration();
-    
-    Flags getStartModeFlag();
-
 }

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/abstractlog/race/state/racingprocedure/line/SWCRacingProcedure.java

@@ -0,0 +1,11 @@
+package com.sap.sailing.domain.abstractlog.race.state.racingprocedure.line;
+
+import com.sap.sailing.domain.base.configuration.procedures.SWCConfiguration;
+import com.sap.sailing.domain.common.racelog.Flags;
+
+public interface SWCRacingProcedure extends ConfigurableStartModeFlagRacingProcedure {
+
+    public final static Flags DefaultStartMode = Flags.UNIFORM;
+    
+    SWCConfiguration getConfiguration();
+}

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/abstractlog/race/state/racingprocedure/line/impl/ConfigurableStartModeFlagRacingProcedureImpl.java

@@ -0,0 +1,40 @@
+package com.sap.sailing.domain.abstractlog.race.state.racingprocedure.line.impl;
+
+import com.sap.sailing.domain.abstractlog.AbstractLogEventAuthor;
+import com.sap.sailing.domain.abstractlog.race.RaceLog;
+import com.sap.sailing.domain.abstractlog.race.analyzing.impl.RaceLogResolver;
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.RacingProcedureChangedListener;
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.impl.BaseRacingProcedure;
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.impl.RacingProcedureChangedListeners;
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.line.LineStartChangedListener;
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.line.ConfigurableStartModeFlagRacingProcedure;
+import com.sap.sailing.domain.base.configuration.RacingProcedureConfiguration;
+import com.sap.sailing.domain.base.configuration.procedures.ConfigurableStartModeFlagRacingProcedureConfiguration;
+
+public abstract class ConfigurableStartModeFlagRacingProcedureImpl extends BaseRacingProcedure implements ConfigurableStartModeFlagRacingProcedure {
+    
+    public ConfigurableStartModeFlagRacingProcedureImpl(RaceLog raceLog, AbstractLogEventAuthor author,
+            RacingProcedureConfiguration configuration, RaceLogResolver raceLogResolver) {
+        super(raceLog, author, configuration, raceLogResolver);
+    }
+
+    @Override
+    protected RacingProcedureChangedListeners<? extends RacingProcedureChangedListener> createChangedListenerContainer() {
+        return new LineStartChangedListeners();
+    }
+    
+    @Override
+    protected LineStartChangedListeners getChangedListeners() {
+        return (LineStartChangedListeners) super.getChangedListeners();
+    }
+
+    @Override
+    public void addChangedListener(LineStartChangedListener listener) {
+        getChangedListeners().add(listener);
+    }
+    
+    @Override
+    public ConfigurableStartModeFlagRacingProcedureConfiguration getConfiguration() {
+        return (ConfigurableStartModeFlagRacingProcedureConfiguration) super.getConfiguration();
+    }
+}

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/abstractlog/race/state/racingprocedure/line/impl/LineStartChangedListeners.java

@@ -0,0 +1,16 @@
+package com.sap.sailing.domain.abstractlog.race.state.racingprocedure.line.impl;
+
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.impl.RacingProcedureChangedListeners;
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.line.LineStartChangedListener;
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.line.ConfigurableStartModeFlagRacingProcedure;
+
+public class LineStartChangedListeners extends RacingProcedureChangedListeners<LineStartChangedListener> implements
+        LineStartChangedListener {
+
+    @Override
+    public void onStartModeChanged(ConfigurableStartModeFlagRacingProcedure racingProcedure) {
+        for (LineStartChangedListener listener : getListeners()) {
+            listener.onStartModeChanged(racingProcedure);
+        }
+    }
+}

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/abstractlog/race/state/racingprocedure/line/impl/RRS26RacingProcedureImpl.java

@@ -1,4 +1,4 @@
-package com.sap.sailing.domain.abstractlog.race.state.racingprocedure.rrs26.impl;
+package com.sap.sailing.domain.abstractlog.race.state.racingprocedure.line.impl;
 
 import java.util.Arrays;
 import java.util.Collection;
@@ -14,21 +14,17 @@ import com.sap.sailing.domain.abstractlog.race.state.RaceStateEvent;
 import com.sap.sailing.domain.abstractlog.race.state.impl.RaceStateEventImpl;
 import com.sap.sailing.domain.abstractlog.race.state.impl.RaceStateEvents;
 import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.FlagPoleState;
-import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.RacingProcedureChangedListener;
 import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.RacingProcedurePrerequisite;
 import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.RacingProcedurePrerequisite.FulfillmentFunction;
-import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.impl.BaseRacingProcedure;
 import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.impl.NoMorePrerequisite;
-import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.impl.RacingProcedureChangedListeners;
-import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.rrs26.RRS26ChangedListener;
-import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.rrs26.RRS26RacingProcedure;
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.line.RRS26RacingProcedure;
 import com.sap.sailing.domain.base.configuration.procedures.RRS26Configuration;
 import com.sap.sailing.domain.common.racelog.FlagPole;
 import com.sap.sailing.domain.common.racelog.Flags;
 import com.sap.sailing.domain.common.racelog.RacingProcedureType;
 import com.sap.sse.common.TimePoint;
 
-public class RRS26RacingProcedureImpl extends BaseRacingProcedure implements RRS26RacingProcedure {
+public class RRS26RacingProcedureImpl extends ConfigurableStartModeFlagRacingProcedureImpl implements RRS26RacingProcedure {
 
     private final static long startPhaseClassUpInterval = 5 * 60 * 1000; // minutes * seconds * milliseconds
     private final static long startPhaseStartModeUpInterval = 4 * 60 * 1000; // minutes * seconds * milliseconds
@@ -87,7 +83,7 @@ public class RRS26RacingProcedureImpl extends BaseRacingProcedure implements RRS
     public RacingProcedurePrerequisite checkPrerequisitesForStart(TimePoint now, TimePoint startTime,
             FulfillmentFunction function) {
         if (startTime.minus(startPhaseStartModeUpInterval).before(now) && !startmodeFlagHasBeenSet) {
-            return new StartmodePrerequisite(function, this, now, startTime);
+            return new StartModePrerequisite(function, this, now, startTime);
         }
         return new NoMorePrerequisite(function);
     }
@@ -177,21 +173,6 @@ public class RRS26RacingProcedureImpl extends BaseRacingProcedure implements RRS
         }
     }
     
-    @Override
-    protected RacingProcedureChangedListeners<? extends RacingProcedureChangedListener> createChangedListenerContainer() {
-        return new RRS26ChangedListeners();
-    }
-    
-    @Override
-    protected RRS26ChangedListeners getChangedListeners() {
-        return (RRS26ChangedListeners) super.getChangedListeners();
-    }
-
-    @Override
-    public void addChangedListener(RRS26ChangedListener listener) {
-        getChangedListeners().add(listener);
-    }
-
     @Override
     public void setStartModeFlag(TimePoint timePoint, Flags startMode) {
         raceLog.add(new RaceLogFlagEventImpl(timePoint, author, raceLog.getCurrentPassId(), startMode, Flags.NONE, true));
@@ -201,7 +182,12 @@ public class RRS26RacingProcedureImpl extends BaseRacingProcedure implements RRS
     public Flags getStartModeFlag() {
         return cachedStartmodeFlag;
     }
-    
+
+    @Override
+    public Flags getDefaultStartMode() {
+        return RRS26RacingProcedure.DefaultStartMode;
+    }
+
     public boolean startmodeFlagHasBeenSet() {
         return startmodeFlagHasBeenSet;
     }
@@ -212,7 +198,7 @@ public class RRS26RacingProcedureImpl extends BaseRacingProcedure implements RRS
         if (startmodeFlag != null && (!startmodeFlag.equals(cachedStartmodeFlag) || !startmodeFlagHasBeenSet)) {
             cachedStartmodeFlag = startmodeFlag;
             startmodeFlagHasBeenSet = true;
-            getChangedListeners().onStartmodeChanged(this);
+            getChangedListeners().onStartModeChanged(this);
         }
         super.update();
     }

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/abstractlog/race/state/racingprocedure/line/impl/SWCRacingProcedureImpl.java

@@ -0,0 +1,194 @@
+package com.sap.sailing.domain.abstractlog.race.state.racingprocedure.line.impl;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+
+import com.sap.sailing.domain.abstractlog.AbstractLogEventAuthor;
+import com.sap.sailing.domain.abstractlog.race.RaceLog;
+import com.sap.sailing.domain.abstractlog.race.analyzing.impl.RaceLogResolver;
+import com.sap.sailing.domain.abstractlog.race.analyzing.impl.RacingProcedureTypeAnalyzer;
+import com.sap.sailing.domain.abstractlog.race.analyzing.impl.SWCStartModeFlagFinder;
+import com.sap.sailing.domain.abstractlog.race.impl.RaceLogFlagEventImpl;
+import com.sap.sailing.domain.abstractlog.race.state.RaceStateEvent;
+import com.sap.sailing.domain.abstractlog.race.state.impl.RaceStateEventImpl;
+import com.sap.sailing.domain.abstractlog.race.state.impl.RaceStateEvents;
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.FlagPoleState;
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.RacingProcedurePrerequisite;
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.RacingProcedurePrerequisite.FulfillmentFunction;
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.impl.NoMorePrerequisite;
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.line.SWCRacingProcedure;
+import com.sap.sailing.domain.base.configuration.procedures.SWCConfiguration;
+import com.sap.sailing.domain.common.racelog.FlagPole;
+import com.sap.sailing.domain.common.racelog.Flags;
+import com.sap.sailing.domain.common.racelog.RacingProcedureType;
+import com.sap.sse.common.TimePoint;
+
+public class SWCRacingProcedureImpl extends ConfigurableStartModeFlagRacingProcedureImpl implements SWCRacingProcedure {
+
+    private final static long CLASS_OVER_OSCAR_AND_STARTMODE_UP_INTERVAL = 6 * 60 * 1000; // 6 minutes before start
+    private final static long CLASS_OVER_OSCAR_AND_STARTMODE_DOWN_INTERVAL = 1 * 60 * 1000; // 1 minute after start
+
+    private final SWCStartModeFlagFinder startModeFlagAnalyzer;
+    
+    private Flags cachedStartmodeFlag;
+    private boolean startmodeFlagHasBeenSet;
+
+    public SWCRacingProcedureImpl(RaceLog raceLog, AbstractLogEventAuthor author, 
+             SWCConfiguration configuration, RaceLogResolver raceLogResolver) {
+        super(raceLog, author, configuration, raceLogResolver);
+        
+        RacingProcedureTypeAnalyzer procedureAnalyzer = new RacingProcedureTypeAnalyzer(raceLog);
+        if (configuration.getStartModeFlags() != null) {
+            this.startModeFlagAnalyzer = new SWCStartModeFlagFinder(procedureAnalyzer, raceLog, configuration.getStartModeFlags());
+        } else {
+            this.startModeFlagAnalyzer = new SWCStartModeFlagFinder(procedureAnalyzer, raceLog);
+        }
+        
+        this.cachedStartmodeFlag = SWCRacingProcedure.DefaultStartMode;
+        this.startmodeFlagHasBeenSet = false;
+        
+        update();
+    }
+
+    @Override
+    public RacingProcedureType getType() {
+        return RacingProcedureType.SWC;
+    }
+    
+    @Override
+    public boolean hasIndividualRecall() {
+        boolean hasRecall = super.hasIndividualRecall();
+        if (!hasRecall) {
+            return false;
+        } else if (startmodeFlagHasBeenSet) {
+            return cachedStartmodeFlag != Flags.BLACK;
+        } else {
+            return hasRecall;
+        }
+    }
+    
+    @Override
+    protected boolean hasIndividualRecallByDefault() {
+        return true;
+    }
+    
+    @Override
+    protected Boolean isResultEntryEnabledByDefault() {
+        return false;
+    }
+
+    @Override
+    public RacingProcedurePrerequisite checkPrerequisitesForStart(TimePoint now, TimePoint startTime,
+            FulfillmentFunction function) {
+        return new NoMorePrerequisite(function);
+    }
+
+    @Override
+    public boolean isStartphaseActive(TimePoint startTime, TimePoint now) {
+        return now.before(startTime.minus(CLASS_OVER_OSCAR_AND_STARTMODE_UP_INTERVAL));
+    }
+
+    @Override
+    protected Collection<RaceStateEvent> createStartStateEvents(TimePoint startTime) {
+        return Arrays.<RaceStateEvent> asList(
+                new RaceStateEventImpl(startTime.minus(CLASS_OVER_OSCAR_AND_STARTMODE_UP_INTERVAL), RaceStateEvents.SWC_CLASS_OVER_OSCAR_UP),
+                new RaceStateEventImpl(startTime.minus(CLASS_OVER_OSCAR_AND_STARTMODE_UP_INTERVAL), RaceStateEvents.SWC_STARTMODE_UP),
+                new RaceStateEventImpl(startTime, RaceStateEvents.START),
+                new RaceStateEventImpl(startTime.plus(CLASS_OVER_OSCAR_AND_STARTMODE_DOWN_INTERVAL), RaceStateEvents.SWC_STARTMODE_DOWN), 
+                new RaceStateEventImpl(startTime.plus(CLASS_OVER_OSCAR_AND_STARTMODE_DOWN_INTERVAL), RaceStateEvents.SWC_CLASS_OVER_OSCAR_DOWN));
+    }
+
+    @Override
+    public boolean processStateEvent(RaceStateEvent event) {
+        switch (event.getEventName()) {
+        case SWC_STARTMODE_UP:
+            if (!startmodeFlagHasBeenSet) {
+                setStartModeFlag(event.getTimePoint(), cachedStartmodeFlag);
+            }
+        case SWC_CLASS_OVER_OSCAR_UP:
+        case SWC_STARTMODE_DOWN:
+        case SWC_CLASS_OVER_OSCAR_DOWN:
+            getChangedListeners().onActiveFlagsChanged(this);
+            return true;
+        default:
+            return super.processStateEvent(event);
+        }
+    }
+
+    @Override
+    public FlagPoleState getActiveFlags(TimePoint startTime, TimePoint now) {
+        Flags classFlag = getConfiguration().getClassFlag() != null ?
+            getConfiguration().getClassFlag() : Flags.CLASS;
+            
+        if (now.before(startTime.minus(CLASS_OVER_OSCAR_AND_STARTMODE_UP_INTERVAL))) {
+            return new FlagPoleState(
+                    Arrays.asList(new FlagPole(classFlag, Flags.OSCAR, false), new FlagPole(cachedStartmodeFlag, false)),
+                    null,
+                    Arrays.asList(new FlagPole(classFlag, Flags.OSCAR, true), new FlagPole(cachedStartmodeFlag, true)), 
+                    startTime.minus(CLASS_OVER_OSCAR_AND_STARTMODE_UP_INTERVAL));
+        } else if (now.before(startTime.plus(CLASS_OVER_OSCAR_AND_STARTMODE_DOWN_INTERVAL))) {
+            return new FlagPoleState(
+                    Arrays.asList(new FlagPole(classFlag,  Flags.OSCAR, true), new FlagPole(cachedStartmodeFlag, true)),
+                    startTime.minus(CLASS_OVER_OSCAR_AND_STARTMODE_UP_INTERVAL),
+                    Arrays.asList(new FlagPole(classFlag,  Flags.OSCAR, false), new FlagPole(cachedStartmodeFlag, false)), 
+                    startTime.plus(CLASS_OVER_OSCAR_AND_STARTMODE_DOWN_INTERVAL));
+        } else {
+            if (isIndividualRecallDisplayed(now)) {
+                return new FlagPoleState(
+                        Arrays.asList(new FlagPole(Flags.XRAY, true)),
+                        getIndividualRecallDisplayedTime(),
+                        Arrays.asList(new FlagPole(Flags.XRAY, false)),
+                        getIndividualRecallRemovalTime());
+            } else if (isFinished(now)) {
+                return new FlagPoleState(
+                        Arrays.asList(new FlagPole(Flags.BLUE, false)), getFinishedTime());
+            } else if (isInFinishingPhase(now)) {
+                return new FlagPoleState(
+                        Arrays.asList(new FlagPole(Flags.BLUE, true)),
+                        getFinishingTime(),
+                        Arrays.asList(new FlagPole(Flags.BLUE, false)),
+                        null);
+            } else {
+                TimePoint recallRemoved = getIndividualRecallRemovalTime();
+                return new FlagPoleState(Collections.<FlagPole>emptyList(), recallRemoved == null ? startTime : recallRemoved);
+            }
+        }
+    }
+    
+    @Override
+    public void setStartModeFlag(TimePoint timePoint, Flags startMode) {
+        raceLog.add(new RaceLogFlagEventImpl(timePoint, author, raceLog.getCurrentPassId(), startMode, Flags.NONE, true));
+    }
+
+    @Override
+    public Flags getStartModeFlag() {
+        return cachedStartmodeFlag;
+    }
+
+    @Override
+    public Flags getDefaultStartMode() {
+        return SWCRacingProcedure.DefaultStartMode;
+    }
+
+    public boolean startmodeFlagHasBeenSet() {
+        return startmodeFlagHasBeenSet;
+    }
+    
+    @Override
+    protected void update() {
+        Flags startmodeFlag = startModeFlagAnalyzer.analyze();
+        if (startmodeFlag != null && (!startmodeFlag.equals(cachedStartmodeFlag) || !startmodeFlagHasBeenSet)) {
+            cachedStartmodeFlag = startmodeFlag;
+            startmodeFlagHasBeenSet = true;
+            getChangedListeners().onStartModeChanged(this);
+        }
+        super.update();
+    }
+    
+    @Override
+    public SWCConfiguration getConfiguration() {
+        return (SWCConfiguration) super.getConfiguration();
+    }
+
+}

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/abstractlog/race/state/racingprocedure/line/impl/StartModePrerequisite.java

@@ -1,14 +1,15 @@
-package com.sap.sailing.domain.abstractlog.race.state.racingprocedure.rrs26.impl;
+package com.sap.sailing.domain.abstractlog.race.state.racingprocedure.line.impl;
 
 import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.RacingProcedurePrerequisite;
-import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.rrs26.RRS26RacingProcedure;
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.impl.BaseRacingProcedurePrerequisite;
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.line.ConfigurableStartModeFlagRacingProcedure;
 import com.sap.sailing.domain.common.racelog.Flags;
 import com.sap.sse.common.TimePoint;
 
-public class StartmodePrerequisite extends BaseRRS26Prerequisite implements RacingProcedurePrerequisite {
+public class StartModePrerequisite extends BaseRacingProcedurePrerequisite implements RacingProcedurePrerequisite {
 
-    public StartmodePrerequisite(FulfillmentFunction function, RRS26RacingProcedure procedure, TimePoint originalNow,
-            TimePoint originalStartTime) {
+    public StartModePrerequisite(FulfillmentFunction function, ConfigurableStartModeFlagRacingProcedure procedure,
+            TimePoint originalNow, TimePoint originalStartTime) {
         super(function, procedure, originalNow, originalStartTime);
     }
 
@@ -24,7 +25,10 @@ public class StartmodePrerequisite extends BaseRRS26Prerequisite implements Raci
     
     @Override
     public void fulfillWithDefault() {
-        fulfill(RRS26RacingProcedure.DefaultStartMode);
+        fulfill(getProcedure().getDefaultStartMode());
+    }
+    
+    protected ConfigurableStartModeFlagRacingProcedure getProcedure() {
+        return (ConfigurableStartModeFlagRacingProcedure) procedure;
     }
-
 }

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/abstractlog/race/state/racingprocedure/rrs26/RRS26ChangedListener.java

@@ -1,9 +0,0 @@
-package com.sap.sailing.domain.abstractlog.race.state.racingprocedure.rrs26;
-
-import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.RacingProcedureChangedListener;
-
-public interface RRS26ChangedListener extends RacingProcedureChangedListener {
-    
-    void onStartmodeChanged(ReadonlyRRS26RacingProcedure racingProcedure);
-
-}

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/abstractlog/race/state/racingprocedure/rrs26/RRS26RacingProcedure.java

@@ -1,10 +0,0 @@
-package com.sap.sailing.domain.abstractlog.race.state.racingprocedure.rrs26;
-
-import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.RacingProcedure;
-import com.sap.sailing.domain.common.racelog.Flags;
-import com.sap.sse.common.TimePoint;
-
-public interface RRS26RacingProcedure extends ReadonlyRRS26RacingProcedure, RacingProcedure  {
-
-    void setStartModeFlag(TimePoint timePoint, Flags startMode);
-}

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/abstractlog/race/state/racingprocedure/rrs26/impl/BaseRRS26Prerequisite.java

@@ -1,22 +0,0 @@
-package com.sap.sailing.domain.abstractlog.race.state.racingprocedure.rrs26.impl;
-
-import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.RacingProcedurePrerequisite;
-import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.impl.BaseRacingProcedurePrerequisite;
-import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.rrs26.RRS26RacingProcedure;
-import com.sap.sse.common.TimePoint;
-
-/**
- * Easy access to the {@link RRS26RacingProcedure}.
- */
-public abstract class BaseRRS26Prerequisite extends BaseRacingProcedurePrerequisite implements RacingProcedurePrerequisite {
-
-    public BaseRRS26Prerequisite(FulfillmentFunction function, RRS26RacingProcedure procedure, TimePoint originalNow,
-            TimePoint originalStartTime) {
-        super(function, procedure, originalNow, originalStartTime);
-    }
-
-    protected RRS26RacingProcedure getProcedure() {
-        return (RRS26RacingProcedure) procedure;
-    }
-
-}

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/abstractlog/race/state/racingprocedure/rrs26/impl/RRS26ChangedListeners.java

@@ -1,17 +0,0 @@
-package com.sap.sailing.domain.abstractlog.race.state.racingprocedure.rrs26.impl;
-
-import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.impl.RacingProcedureChangedListeners;
-import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.rrs26.RRS26ChangedListener;
-import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.rrs26.ReadonlyRRS26RacingProcedure;
-
-public class RRS26ChangedListeners extends RacingProcedureChangedListeners<RRS26ChangedListener> implements
-        RRS26ChangedListener {
-
-    @Override
-    public void onStartmodeChanged(ReadonlyRRS26RacingProcedure racingProcedure) {
-        for (RRS26ChangedListener listener : getListeners()) {
-            listener.onStartmodeChanged(racingProcedure);
-        }
-    }
-
-}

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/base/configuration/RegattaConfiguration.java

@@ -7,6 +7,7 @@ import com.sap.sailing.domain.base.configuration.procedures.ESSConfiguration;
 import com.sap.sailing.domain.base.configuration.procedures.GateStartConfiguration;
 import com.sap.sailing.domain.base.configuration.procedures.LeagueConfiguration;
 import com.sap.sailing.domain.base.configuration.procedures.RRS26Configuration;
+import com.sap.sailing.domain.base.configuration.procedures.SWCConfiguration;
 import com.sap.sailing.domain.common.CourseDesignerMode;
 import com.sap.sailing.domain.common.racelog.RacingProcedureType;
 
@@ -31,7 +32,13 @@ public interface RegattaConfiguration extends Serializable, Cloneable {
      * @return <code>null</code> if there is no configuration.
      */
     RRS26Configuration getRRS26Configuration();
-    
+
+    /**
+     * Gets the configuration for SWC races.
+     * @return <code>null</code> if there is no configuration.
+     */
+    SWCConfiguration getSWCConfiguration();
+
     /**
      * Gets the configuration for Gate Start races.
      * @return <code>null</code> if there is no configuration.

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/base/configuration/impl/ESSConfigurationImpl.java

@@ -1,21 +1,12 @@
 package com.sap.sailing.domain.base.configuration.impl;
 
-import com.sap.sailing.domain.base.configuration.RacingProcedureConfiguration;
 import com.sap.sailing.domain.base.configuration.procedures.ESSConfiguration;
 
 public class ESSConfigurationImpl extends RacingProcedureConfigurationImpl implements ESSConfiguration {
 
     private static final long serialVersionUID = 5406098147408723197L;
 
-    protected ESSConfiguration copy() {
-        ESSConfigurationImpl copy = (ESSConfigurationImpl) super.copy(new ESSConfigurationImpl());
-        return copy;
+    protected ESSConfigurationImpl newInstance() {
+        return new ESSConfigurationImpl();
     }
-    
-    @Override
-    public RacingProcedureConfiguration merge(RacingProcedureConfiguration update) {
-        ESSConfigurationImpl target = (ESSConfigurationImpl) super.merge(update);
-        return target;
-    }
-
 }

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/base/configuration/impl/EmptyRegattaConfiguration.java

@@ -18,6 +18,7 @@ public class EmptyRegattaConfiguration extends RegattaConfigurationImpl implemen
         setDefaultRacingProcedureType(RacingProcedureType.UNKNOWN);
         setDefaultCourseDesignerMode(CourseDesignerMode.UNKNOWN);
         setRRS26Configuration(new RRS26ConfigurationImpl());
+        setSWCConfiguration(new SWCConfigurationImpl());
         setGateStartConfiguration(new GateStartConfigurationImpl());
         setESSConfiguration(new ESSConfigurationImpl());
         setBasicConfiguration(new RacingProcedureConfigurationImpl());

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/base/configuration/impl/GateStartConfigurationImpl.java

@@ -41,12 +41,16 @@ public class GateStartConfigurationImpl extends RacingProcedureConfigurationImpl
         return target;
     }
     
+    
+    @Override
+    protected GateStartConfigurationImpl newInstance() {
+        return new GateStartConfigurationImpl();
+    }
+
     protected GateStartConfiguration copy() {
-        GateStartConfigurationImpl copy = (GateStartConfigurationImpl) super.copy(new GateStartConfigurationImpl());
+        GateStartConfigurationImpl copy = (GateStartConfigurationImpl) super.copy();
         copy.setHasPathfinder(hasPathfinder);
         copy.setHasAdditionalGolfDownTime(hasAdditionalGolfDownTime);
         return copy;
     }
-    
-
 }

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/base/configuration/impl/LeagueConfigurationImpl.java

@@ -1,20 +1,11 @@
 package com.sap.sailing.domain.base.configuration.impl;
 
-import com.sap.sailing.domain.base.configuration.RacingProcedureConfiguration;
 import com.sap.sailing.domain.base.configuration.procedures.LeagueConfiguration;
 
 public class LeagueConfigurationImpl extends RacingProcedureConfigurationImpl implements LeagueConfiguration {
     private static final long serialVersionUID = 3625803505541394766L;
 
-    protected LeagueConfigurationImpl copy() {
-        LeagueConfigurationImpl copy = (LeagueConfigurationImpl) super.copy(new LeagueConfigurationImpl());
-        return copy;
+    protected LeagueConfigurationImpl newInstance() {
+        return new LeagueConfigurationImpl();
     }
-    
-    @Override
-    public RacingProcedureConfiguration merge(RacingProcedureConfiguration update) {
-        LeagueConfigurationImpl target = (LeagueConfigurationImpl) super.merge(update);
-        return target;
-    }
-
 }

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/base/configuration/impl/RRS26ConfigurationImpl.java

@@ -1,27 +1,13 @@
 package com.sap.sailing.domain.base.configuration.impl;
 
-import java.util.List;
-
 import com.sap.sailing.domain.base.configuration.RacingProcedureConfiguration;
 import com.sap.sailing.domain.base.configuration.procedures.RRS26Configuration;
-import com.sap.sailing.domain.common.racelog.Flags;
 
-public class RRS26ConfigurationImpl extends RacingProcedureConfigurationImpl implements
-        RRS26Configuration {
+public class RRS26ConfigurationImpl extends RacingProcedureWithConfigurableStartModeFlagConfigurationImpl
+        implements RRS26Configuration {
 
     private static final long serialVersionUID = 260941807346644026L;
     
-    private List<Flags> startModeFlags;
-
-    @Override
-    public List<Flags> getStartModeFlags() {
-        return startModeFlags;
-    }
-    
-    public void setStartModeFlags(List<Flags> flags) {
-        this.startModeFlags = flags;
-    }
-    
     @Override
     public RacingProcedureConfiguration merge(RacingProcedureConfiguration value) {
         RRS26Configuration update = (RRS26Configuration) value;
@@ -32,10 +18,8 @@ public class RRS26ConfigurationImpl extends RacingProcedureConfigurationImpl imp
         return target;
     }
 
-    protected RRS26Configuration copy() {
-        RRS26ConfigurationImpl copy = (RRS26ConfigurationImpl) super.copy(new RRS26ConfigurationImpl());
-        copy.setStartModeFlags(startModeFlags);
-        return copy;
+    protected RRS26ConfigurationImpl newInstance() {
+        return new RRS26ConfigurationImpl();
     }
 
 }

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/base/configuration/impl/RacingProcedureConfigurationImpl.java

@@ -49,8 +49,12 @@ public class RacingProcedureConfigurationImpl implements RacingProcedureConfigur
         this.isResultEntryEnabled = isResultEntryEnabled;
     }
 
+    protected RacingProcedureConfigurationImpl newInstance() {
+        return new RacingProcedureConfigurationImpl();
+    }
+    
     protected RacingProcedureConfiguration copy() {
-        return copy(new RacingProcedureConfigurationImpl());
+        return copy(newInstance());
     }
     
     protected RacingProcedureConfiguration copy(RacingProcedureConfigurationImpl target) {

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/base/configuration/impl/RacingProcedureWithConfigurableStartModeFlagConfigurationImpl.java

@@ -0,0 +1,39 @@
+package com.sap.sailing.domain.base.configuration.impl;
+
+import java.util.List;
+
+import com.sap.sailing.domain.base.configuration.RacingProcedureConfiguration;
+import com.sap.sailing.domain.base.configuration.procedures.ConfigurableStartModeFlagRacingProcedureConfiguration;
+import com.sap.sailing.domain.common.racelog.Flags;
+
+public abstract class RacingProcedureWithConfigurableStartModeFlagConfigurationImpl extends RacingProcedureConfigurationImpl implements ConfigurableStartModeFlagRacingProcedureConfiguration {
+
+    private static final long serialVersionUID = 5141617199229598965L;
+
+    private List<Flags> startModeFlags;
+
+    @Override
+    public List<Flags> getStartModeFlags() {
+        return startModeFlags;
+    }
+    
+    public void setStartModeFlags(List<Flags> flags) {
+        this.startModeFlags = flags;
+    }
+    
+    @Override
+    public RacingProcedureConfiguration merge(RacingProcedureConfiguration value) {
+        ConfigurableStartModeFlagRacingProcedureConfiguration update = (ConfigurableStartModeFlagRacingProcedureConfiguration) value;
+        RacingProcedureWithConfigurableStartModeFlagConfigurationImpl target = (RacingProcedureWithConfigurableStartModeFlagConfigurationImpl) super.merge(update);
+        if (update.getStartModeFlags() != null) {
+            target.setStartModeFlags(update.getStartModeFlags());
+        }
+        return target;
+    }
+
+    protected ConfigurableStartModeFlagRacingProcedureConfiguration copy() {
+        RacingProcedureWithConfigurableStartModeFlagConfigurationImpl copy = (RacingProcedureWithConfigurableStartModeFlagConfigurationImpl) super.copy();
+        copy.setStartModeFlags(startModeFlags);
+        return copy;
+    }
+}

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/base/configuration/impl/RegattaConfigurationImpl.java

@@ -6,6 +6,7 @@ import com.sap.sailing.domain.base.configuration.procedures.ESSConfiguration;
 import com.sap.sailing.domain.base.configuration.procedures.GateStartConfiguration;
 import com.sap.sailing.domain.base.configuration.procedures.LeagueConfiguration;
 import com.sap.sailing.domain.base.configuration.procedures.RRS26Configuration;
+import com.sap.sailing.domain.base.configuration.procedures.SWCConfiguration;
 import com.sap.sailing.domain.common.CourseDesignerMode;
 import com.sap.sailing.domain.common.racelog.RacingProcedureType;
 
@@ -17,6 +18,7 @@ public class RegattaConfigurationImpl implements RegattaConfiguration {
     private CourseDesignerMode defaultCourseDesignerMode;
     
     private RRS26Configuration rrs26Configuration;
+    private SWCConfiguration swcConfiguration;
     private GateStartConfiguration gateStartConfiguration;
     private ESSConfiguration essConfiguration;
     private LeagueConfiguration leagueConfiguration;
@@ -49,6 +51,15 @@ public class RegattaConfigurationImpl implements RegattaConfiguration {
         this.rrs26Configuration = rrs26Configuration;
     }
 
+    @Override
+    public SWCConfiguration getSWCConfiguration() {
+        return swcConfiguration;
+    }
+
+    public void setSWCConfiguration(SWCConfiguration swcConfiguration) {
+        this.swcConfiguration = swcConfiguration;
+    }
+
     @Override
     public GateStartConfiguration getGateStartConfiguration() {
         return gateStartConfiguration;
@@ -91,6 +102,7 @@ public class RegattaConfigurationImpl implements RegattaConfiguration {
         copy.setDefaultRacingProcedureType(defaultRacingProcedureType);
         copy.setDefaultCourseDesignerMode(defaultCourseDesignerMode);
         copy.setRRS26Configuration(rrs26Configuration);
+        copy.setSWCConfiguration(swcConfiguration);
         copy.setGateStartConfiguration(gateStartConfiguration);
         copy.setESSConfiguration(essConfiguration);
         copy.setBasicConfiguration(basicConfiguration);
@@ -112,6 +124,10 @@ public class RegattaConfigurationImpl implements RegattaConfiguration {
             target.setRRS26Configuration(
                     (RRS26Configuration) target.getRRS26Configuration().merge(update.getRRS26Configuration()));
         }
+        if (update.getSWCConfiguration() != null) {
+            target.setSWCConfiguration(
+                    (SWCConfiguration) target.getSWCConfiguration().merge(update.getSWCConfiguration()));
+        }
         if (update.getGateStartConfiguration() != null) {
             target.setGateStartConfiguration(
                     (GateStartConfiguration) target.getGateStartConfiguration().merge(update.getGateStartConfiguration()));

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/base/configuration/impl/SWCConfigurationImpl.java

@@ -0,0 +1,20 @@
+package com.sap.sailing.domain.base.configuration.impl;
+
+import com.sap.sailing.domain.base.configuration.RacingProcedureConfiguration;
+import com.sap.sailing.domain.base.configuration.procedures.SWCConfiguration;
+
+public class SWCConfigurationImpl extends RacingProcedureWithConfigurableStartModeFlagConfigurationImpl
+        implements SWCConfiguration {
+
+    private static final long serialVersionUID = 5141617199229598965L;
+
+    @Override
+    public RacingProcedureConfiguration merge(RacingProcedureConfiguration value) {
+        SWCConfiguration update = (SWCConfiguration) value;
+        SWCConfigurationImpl target = (SWCConfigurationImpl) super.merge(update);
+        if (update.getStartModeFlags() != null) {
+            target.setStartModeFlags(update.getStartModeFlags());
+        }
+        return target;
+    }
+}

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/base/configuration/procedures/ConfigurableStartModeFlagRacingProcedureConfiguration.java

@@ -0,0 +1,12 @@
+package com.sap.sailing.domain.base.configuration.procedures;
+
+import java.util.List;
+
+import com.sap.sailing.domain.base.configuration.RacingProcedureConfiguration;
+import com.sap.sailing.domain.common.racelog.Flags;
+
+public interface ConfigurableStartModeFlagRacingProcedureConfiguration extends RacingProcedureConfiguration {
+    
+    List<Flags> getStartModeFlags();
+
+}

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/base/configuration/procedures/RRS26Configuration.java

@@ -1,12 +1,4 @@
-package com.sap.sailing.domain.base.configuration.procedures;
-
-import java.util.List;
-
-import com.sap.sailing.domain.base.configuration.RacingProcedureConfiguration;
-import com.sap.sailing.domain.common.racelog.Flags;
-
-public interface RRS26Configuration extends RacingProcedureConfiguration {
-    
-    List<Flags> getStartModeFlags();
-
-}
+package com.sap.sailing.domain.base.configuration.procedures;
+
+public interface RRS26Configuration extends ConfigurableStartModeFlagRacingProcedureConfiguration {
+}

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/base/configuration/procedures/SWCConfiguration.java

@@ -0,0 +1,10 @@
+package com.sap.sailing.domain.base.configuration.procedures;
+
+
+/**
+ * Start procedure for the Sailing World Cup
+ * @author Frank
+ *
+ */
+public interface SWCConfiguration extends ConfigurableStartModeFlagRacingProcedureConfiguration {
+}

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/regattaoverview/client/FlagImageResolver.java

@@ -38,6 +38,7 @@ public class FlagImageResolver {
         flagImageMap.put(Flags.UNIFORM, resources.flagUniform());
         flagImageMap.put(Flags.XRAY, resources.flagXray());
         flagImageMap.put(Flags.ZULU, resources.flagZulu());
+        flagImageMap.put(Flags.OSCAR, resources.flagOscar());
     }
     
     public ImageResource resolveFlagToImage(Flags flag, boolean isDisplayed, boolean displayStateChanged) {

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/regattaoverview/client/RaceDetailPanel.java

@@ -16,7 +16,7 @@ import com.google.gwt.user.client.ui.SimplePanel;
 import com.google.gwt.user.client.ui.VerticalPanel;
 import com.sap.sailing.gwt.ui.client.StringMessages;
 import com.sap.sailing.gwt.ui.shared.RaceInfoDTO.GateStartInfoDTO;
-import com.sap.sailing.gwt.ui.shared.RaceInfoDTO.RRS26InfoDTO;
+import com.sap.sailing.gwt.ui.shared.RaceInfoDTO.LineStartInfoDTO;
 import com.sap.sailing.gwt.ui.shared.RegattaOverviewEntryDTO;
 
 public class RaceDetailPanel extends SimplePanel {
@@ -222,7 +222,8 @@ public class RaceDetailPanel extends SimplePanel {
             if (data.raceInfo.startProcedureDTO != null) {
                 switch (data.raceInfo.startProcedure) {
                 case RRS26:
-                    RRS26InfoDTO rrsInfo = (RRS26InfoDTO) data.raceInfo.startProcedureDTO;
+                case SWC:    
+                    LineStartInfoDTO rrsInfo = (LineStartInfoDTO) data.raceInfo.startProcedureDTO;
                     if (rrsInfo != null) {
                         if (rrsInfo.startModeFlag != null) {
                             showProcedureInfo("Start mode", rrsInfo.startModeFlag.toString());

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/regattaoverview/client/RegattaRaceStatesFlagsResources.java

@@ -54,7 +54,10 @@ interface RegattaRaceStatesFlagsResources extends ClientBundle {
     
     @Source("com/sap/sailing/gwt/ui/client/images/flags/flags_racecommittee/uniform.png")
     ImageResource flagUniform();
-    
+
+    @Source("com/sap/sailing/gwt/ui/client/images/flags/flags_racecommittee/oscar.png")
+    ImageResource flagOscar();
+
     @Source("com/sap/sailing/gwt/ui/client/images/flags/flags_racecommittee/whiskey.png")
     ImageResource flagWhiskey();
     

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/adminconsole/RegattaConfigurationDialog.java

@@ -44,6 +44,13 @@ public class RegattaConfigurationDialog extends DataEntryDialog<DeviceConfigurat
     private CheckBox rrs26ResultEntryBox;
     private ListBox rrs26StartModeFlagsBox;
 
+    private DisclosurePanel swcStartDisclosurePanel;
+    private CheckBox swcStartEnabledBox;
+    private ListBox swcStartClassFlagListBox;
+    private CheckBox swcStartRecallBox;
+    private CheckBox swcStartResultEntryBox;
+    private ListBox swcStartModeFlagsBox;
+
     private DisclosurePanel gateStartDisclosurePanel;
     private CheckBox gateStartEnabledBox;
     private ListBox gateStartClassFlagListBox;
@@ -82,6 +89,7 @@ public class RegattaConfigurationDialog extends DataEntryDialog<DeviceConfigurat
         contentPanel = new VerticalPanel();
         setupGeneral();
         setupRRS26();
+        setupSWCStart();
         setupGateStart();
         setupESS();
         setupBasic();
@@ -90,6 +98,9 @@ public class RegattaConfigurationDialog extends DataEntryDialog<DeviceConfigurat
         if (rrs26EnabledBox.getValue()) {
             rrs26DisclosurePanel.setOpen(true);
         }
+        if (swcStartEnabledBox.getValue()) {
+            swcStartDisclosurePanel.setOpen(true);
+        }
         if (gateStartEnabledBox.getValue()) {
             gateStartDisclosurePanel.setOpen(true);
         }
@@ -245,6 +256,66 @@ public class RegattaConfigurationDialog extends DataEntryDialog<DeviceConfigurat
         });
     }
 
+    private void setupSWCStart() {
+        swcStartDisclosurePanel = new DisclosurePanel(stringMessages.sailingWorldCupStart());
+        VerticalPanel panel = new VerticalPanel();
+
+        Grid grid = new Grid(4, 3);
+        swcStartEnabledBox = new CheckBox(stringMessages.setConfiguration());
+        swcStartEnabledBox.addValueChangeHandler(new ValueChangeHandler<Boolean>() {
+            @Override
+            public void onValueChange(ValueChangeEvent<Boolean> event) {
+                boolean isActive = event.getValue();
+                swcStartClassFlagListBox.setEnabled(isActive);
+                swcStartRecallBox.setEnabled(isActive);
+                swcStartResultEntryBox.setEnabled(isActive);
+                swcStartModeFlagsBox.setEnabled(isActive);
+            }
+        });
+        swcStartClassFlagListBox = setupClassFlagListBox(originalConfiguration == null ? null
+                : originalConfiguration.swcStartConfiguration);
+        swcStartClassFlagListBox.setWidth("100%");
+        swcStartRecallBox = setupRecallBox(originalConfiguration==null?null:originalConfiguration.swcStartConfiguration);
+        swcStartResultEntryBox = setupResultEntryBox(originalConfiguration==null?null:originalConfiguration.swcStartConfiguration);
+        setupSWCStartModeFlags();
+
+        grid.setWidget(0, 0, new Label(stringMessages.classFlag() + ":"));
+        grid.setWidget(0, 1, swcStartClassFlagListBox);
+        grid.setWidget(0, 2, createHelpImage(stringMessages.classFlagHelpText("SWC Start")));
+        grid.setWidget(1, 0, swcStartRecallBox);
+        grid.setWidget(1, 2, createHelpImage(stringMessages.individualRecallHelpText()));
+        grid.setWidget(2, 0, swcStartResultEntryBox);
+        grid.setWidget(2, 2, createHelpImage(stringMessages.resultEntryHelpText()));
+        grid.setWidget(3, 0, new Label(stringMessages.startmodeFlags() + ":"));
+        grid.setWidget(3, 1, swcStartModeFlagsBox);
+        grid.setWidget(3, 2, createHelpImage(stringMessages.startmodeFlagsHelpText()));
+
+        swcStartEnabledBox.setValue(originalConfiguration != null && originalConfiguration.swcStartConfiguration != null);
+        ValueChangeEvent.fire(swcStartEnabledBox, swcStartEnabledBox.getValue());
+
+        panel.add(swcStartEnabledBox);
+        panel.add(grid);
+        swcStartDisclosurePanel.add(panel);
+        contentPanel.add(swcStartDisclosurePanel);
+    }
+
+    private void setupSWCStartModeFlags() {
+        swcStartModeFlagsBox = new ListBox();
+        swcStartModeFlagsBox.setMultipleSelect(true);
+        swcStartModeFlagsBox.setWidth("100%");
+        List<Flags> selectedFlags = new ArrayList<Flags>();
+        if (originalConfiguration != null && originalConfiguration.swcStartConfiguration != null
+                && originalConfiguration.swcStartConfiguration.startModeFlags != null) {
+            selectedFlags = originalConfiguration.swcStartConfiguration.startModeFlags;
+        }
+        ListBoxUtils.setupStartmodeFlagsListBox(swcStartModeFlagsBox, selectedFlags);
+        swcStartModeFlagsBox.addChangeHandler(new ChangeHandler() {
+            @Override
+            public void onChange(ChangeEvent event) {
+            }
+        });
+    }
+
     private void setupGateStart() {
         gateStartDisclosurePanel = new DisclosurePanel(stringMessages.gateStart());
         VerticalPanel panel = new VerticalPanel();
@@ -440,6 +511,17 @@ public class RegattaConfigurationDialog extends DataEntryDialog<DeviceConfigurat
             }
             result.rrs26Configuration.startModeFlags = flags.isEmpty() ? null : flags;
         }
+        if (swcStartEnabledBox.getValue()) {
+            result.swcStartConfiguration = new DeviceConfigurationDTO.RegattaConfigurationDTO.SWCStartConfigurationDTO();
+            getRacingProcedureConfigurationResults(result.swcStartConfiguration, swcStartClassFlagListBox, swcStartRecallBox, swcStartResultEntryBox);
+            List<Flags> flags = new ArrayList<Flags>();
+            for (int i = 0; i < swcStartModeFlagsBox.getItemCount(); i++) {
+                if (swcStartModeFlagsBox.isItemSelected(i)) {
+                    flags.add(Flags.valueOf(swcStartModeFlagsBox.getValue(i)));
+                }
+            }
+            result.swcStartConfiguration.startModeFlags = flags.isEmpty() ? null : flags;
+        }
         if (gateStartEnabledBox.getValue()) {
             result.gateStartConfiguration = new DeviceConfigurationDTO.RegattaConfigurationDTO.GateStartConfigurationDTO();
             getRacingProcedureConfigurationResults(result.gateStartConfiguration, gateStartClassFlagListBox,

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/StringMessages.java

@@ -988,6 +988,7 @@ public interface StringMessages extends com.sap.sse.gwt.client.StringMessages,
     String activateIndividualRecall();
     String activateResultEntry();
     String rrs26Start();
+    String sailingWorldCupStart();
     String setConfiguration();
     String classFlag();
     String classFlagHelpText(String procedure);
@@ -1184,6 +1185,7 @@ public interface StringMessages extends com.sap.sse.gwt.client.StringMessages,
     String raceIsInLiveTimePanelMode();
     String backToLiveTimePanelMode();
     String windChart();
+    String windChartLoading();
     String mediaNoVideosCaption();
     String mediaShowVideoCaption();
     String mediaShowVideoTooltip(String title);

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/StringMessages.properties

@@ -959,6 +959,7 @@ racingProcedureConfiguration=Regatta configuration
 activateIndividualRecall=Activate individual recall
 activateResultEntry=Activate result entry
 rrs26Start=RRS26 start
+sailingWorldCupStart=Sailing World Cup Start
 setConfiguration=Activate configuration
 classFlag=Class flag
 classFlagHelpText=Sets the class flag used for {0}. Choose ''Don''t Overwrite'' to activate the procedure''s default flag.
@@ -1156,6 +1157,7 @@ leaderboardGroupNotContainedInEvent=The leaderboard group {0} is not contained i
 raceIsInLiveTimePanelMode=Race is Live
 backToLiveTimePanelMode=Back to Live
 windChart=Wind Chart
+windChartLoading=Loading wind data...
 mediaNoVideosCaption=No Videos
 mediaShowVideoCaption=Show Video
 mediaShowVideoTooltip=Click to show video: {0}

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/StringMessages_de.properties

@@ -532,7 +532,7 @@ legend=Legende
 live=live
 swissTimingArchiveConnector=SwissTiming Historische Veranstaltungen
 errorFetchingChartData=Fehler beim Laden der Chartdaten: {0}
-loadingCompetitorData=Lade Teilnehmer-Daten
+loadingCompetitorData=Lade Teilnehmer-Daten...
 competitorRegattaDataAfterRaceN={0} nach Rennen {1}
 rankChart=Ranking
 netPoints=Gesamtpunktzahl
@@ -952,6 +952,7 @@ racingProcedureConfiguration=Rennart-Konfiguration
 activateIndividualRecall=Aktiviere Einzelrückruf
 activateResultEntry=Aktiviere Ergebniseingabe
 rrs26Start=RRS26 Start
+sailingWorldCupStart=Sailing World Cup Start
 setConfiguration=Aktiviere Konfiguration
 classFlag=Klassenflagge
 classFlagHelpText=Setzt die Klassenflagge für {0}. Wähle 'Nicht überschreiben' um die Standardflagge der Rennart zu wählen.
@@ -1148,6 +1149,7 @@ leaderboardGroupNotContainedInEvent=Die Wettfahrtgruppe {0} gehört nicht zur Ve
 raceIsInLiveTimePanelMode=Rennen ist live
 backToLiveTimePanelMode=Zurück zu live
 windChart=Winddiagramm
+windChartLoading=Winddaten werden geladen...
 mediaNoVideosCaption=Keine Videos
 mediaShowVideoCaption=Video ein
 mediaShowVideoTooltip=Video abspielen: {0}

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/StringMessages_ja.properties

@@ -956,6 +956,7 @@ racingProcedureConfiguration=レガッタ設定
 activateIndividualRecall=個別リコール有効化
 activateResultEntry=結果エントリ有効化
 rrs26Start=RRS26 開始
+sailingWorldCupStart=Sailing World Cup Start
 setConfiguration=設定有効化
 classFlag=クラス旗
 classFlagHelpText={0} に使用するクラス旗を選定します。手順にある初期値の旗を有効化するには、''上書きしない'' を選択してください。

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/StringMessages_ru.properties

@@ -956,6 +956,7 @@ racingProcedureConfiguration=Конфигурация регаты
 activateIndividualRecall=Активировать индивидуальный отзыв
 activateResultEntry=Активировать запись результата
 rrs26Start=RRS26 старт
+sailingWorldCupStart=Sailing World Cup Start
 setConfiguration=Активировать конфигурацию
 classFlag=Флаг класса
 classFlagHelpText=Установка флага класса для {0}. Выберите ''Не перезаписывать'', чтобы активировать соответствующий флаг процедуры по умолчанию.

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/StringMessages_zh.properties

@@ -956,6 +956,7 @@ racingProcedureConfiguration=比赛配置
 activateIndividualRecall=激活个别召回
 activateResultEntry=激活结果条目
 rrs26Start=RRS26 开始
+sailingWorldCupStart=Sailing World Cup Start
 setConfiguration=激活配置
 classFlag=级别旗标
 classFlagHelpText=设置用于{0}的级别旗标。 选择“不要覆盖”，激活程序的默认旗标。

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/StringMessages_zh_CN.properties

@@ -956,6 +956,7 @@ racingProcedureConfiguration=比赛配置
 activateIndividualRecall=激活个别召回
 activateResultEntry=激活结果条目
 rrs26Start=RRS26 开始
+sailingWorldCupStart=Sailing World Cup Start
 setConfiguration=激活配置
 classFlag=级别旗标
 classFlagHelpText=设置用于{0}的级别旗标。 选择“不要覆盖”，激活程序的默认旗标。

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/shared/charts/AbstractCompetitorRaceChart.java

@@ -221,7 +221,11 @@ public abstract class AbstractCompetitorRaceChart<SettingsType extends ChartSett
 
     private void loadData(final Date from, final Date to, final List<CompetitorDTO> competitors, final boolean append) {
         if (isVisible()) {
-            showLoading(stringMessages.loadingCompetitorData());
+            // if no data is loaded yet, or if it is not playing and not live (append loading every second) show loading
+            // indicator
+            if (shouldShowLoading(primary.timeOfLatestRequestInMillis)) {
+                showLoading(stringMessages.loadingCompetitorData());
+            }
             ArrayList<CompetitorDTO> competitorsToLoad = new ArrayList<CompetitorDTO>();
             for (CompetitorDTO competitorDTO : competitors) {
                 competitorsToLoad.add(competitorDTO);
@@ -282,6 +286,7 @@ public abstract class AbstractCompetitorRaceChart<SettingsType extends ChartSett
     @Override
     public void addedToSelection(CompetitorDTO competitor) {
         if (isVisible()) {
+            showLoading(stringMessages.loadingCompetitorData());
             ArrayList<CompetitorDTO> competitorsToLoad = new ArrayList<CompetitorDTO>();
             competitorsToLoad.add(competitor);
             

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/shared/charts/AbstractRaceChart.java

@@ -35,6 +35,7 @@ import com.sap.sse.gwt.client.player.TimeRangeWithZoomProvider;
 import com.sap.sse.gwt.client.player.TimeZoomChangeListener;
 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.components.Component;
 import com.sap.sse.gwt.client.shared.components.SettingsDialog;
 
@@ -137,20 +138,16 @@ public abstract class AbstractRaceChart<SettingsType extends Settings> extends A
     }
 
     protected void showLoading(String message) {
-        if (timer.getPlayMode() != PlayModes.Live) {
-            if (chart.isRendered()) {
-                chart.showLoading(message);
-            } else {
-                add(busyIndicator);
-            }
+        if (chart.isRendered()) {
+            chart.showLoading(message);
+        } else {
+            add(busyIndicator);
         }
         isLoading = true;
     }
 
     protected void hideLoading() {
-        if (timer.getPlayMode() != PlayModes.Live) {
-            chart.hideLoading();
-        }
+        chart.hideLoading();
         isLoading = false;
         remove(busyIndicator);
     }
@@ -261,4 +258,14 @@ public abstract class AbstractRaceChart<SettingsType extends Settings> extends A
     public String getId() {
         return getLocalizedShortName();
     }
+
+    /**
+     * Determines if a standard loading message is allowed to appear over the chart or not.
+     * 
+     * @return <code>true</code> if the message is allowed, <code>false</code> otherwise.
+     */
+    protected boolean shouldShowLoading(Long timestamp) {
+        return timestamp == null
+                || (timer.getPlayState() != PlayStates.Playing && timer.getPlayMode() != PlayModes.Live);
+    }
 }

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/shared/charts/WindChart.java

@@ -468,7 +468,10 @@ public class WindChart extends AbstractRaceChart<WindChartSettings> implements R
                 clearChart();
             } else if (needsDataLoading() && from != null && to != null) {
                 setWidget(chart);
-                showLoading("Loading wind data...");
+                // if not playing or empty show loading message
+                if (shouldShowLoading(timeOfLatestRequestInMillis)) {
+                    showLoading(stringMessages.windChartLoading());
+                }
                 GetWindInfoAction getWindInfoAction = new GetWindInfoAction(sailingService, selectedRaceIdentifier,
                         from, to, settings.getResolutionInMilliseconds(), null, /* onlyUpToNewestEvent==true because we don't want
                         to overshoot the evidence so far */ true);

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/shared/racemap/FixesAndTails.java

@@ -21,6 +21,8 @@ import com.sap.sailing.gwt.ui.client.SailingServiceAsync;
 import com.sap.sailing.gwt.ui.shared.GPSFixDTOWithSpeedWindTackAndLegType;
 import com.sap.sse.common.Util;
 import com.sap.sse.common.Util.Triple;
+import com.sap.sse.common.impl.MillisecondsTimePoint;
+import com.sap.sse.common.impl.TimeRangeImpl;
 import com.sap.sse.common.util.Trigger;
 import com.sap.sse.common.util.Triggerable;
 import com.sap.sse.gwt.client.TriggerableTimer;
@@ -225,31 +227,44 @@ public class FixesAndTails {
             Map<CompetitorDTO, Boolean> overlapsWithKnownFixes, TailFactory tailFactory, long timeForPositionTransitionMillis) {
         for (final Map.Entry<CompetitorDTO, List<GPSFixDTOWithSpeedWindTackAndLegType>> e : fixesForCompetitors.entrySet()) {
             if (e.getValue() != null && !e.getValue().isEmpty()) {
-                List<GPSFixDTOWithSpeedWindTackAndLegType> fixesForCompetitor = fixes.get(e.getKey());
+                final CompetitorDTO competitor = e.getKey();
+                List<GPSFixDTOWithSpeedWindTackAndLegType> fixesForCompetitor = fixes.get(competitor);
                 if (fixesForCompetitor == null) {
                     fixesForCompetitor = new ArrayList<GPSFixDTOWithSpeedWindTackAndLegType>();
-                    fixes.put(e.getKey(), fixesForCompetitor);
+                    fixes.put(competitor, fixesForCompetitor);
                 }
-                if (!overlapsWithKnownFixes.get(e.getKey())) {
+                if (!overlapsWithKnownFixes.get(competitor)) {
                     // clearing and then re-populating establishes the invariant that an extrapolated fix must be the last
                     fixesForCompetitor.clear();
                     // to re-establish the invariants for tails, firstShownFix and lastShownFix, we now need to remove
                     // all points from the competitor's polyline and clear the entries in firstShownFix and lastShownFix
-                    final Triggerable triggerable = new Triggerable(new Runnable() { @Override public void run() { clearTail(e.getKey()); } });
-                    final Trigger<Polyline> tailTrigger = tails.get(e.getKey());
-                    if (tailTrigger != null) {
-                        tailTrigger.register(triggerable);
-                    }
-                    registerIndexTrigger(triggerable, firstShownFix, e.getKey());
-                    registerIndexTrigger(triggerable, lastShownFix, e.getKey());
+                    final Triggerable triggerable = new Triggerable(new Runnable() { @Override public void run() { clearTail(competitor); } });
+                    registerTriggerable(competitor, triggerable);
                     fixesForCompetitor.addAll(e.getValue());
-                    overlapsWithKnownFixes.put(e.getKey(), true); // In case this was only one part of a split request, the next request *does* have an overlap
+                    overlapsWithKnownFixes.put(competitor, true); // In case this was only one part of a split request, the next request *does* have an overlap
                 } else {
-                    mergeFixes(e.getKey(), e.getValue(), timeForPositionTransitionMillis);
+                    mergeFixes(competitor, e.getValue(), timeForPositionTransitionMillis);
                 }
             }
         }
     }
+
+    /**
+     * A {@link Triggerable} that is usually a {@link TriggerableTimer} and is or will be scheduled for delayed execution
+     * will be registered with the {@link #tails}, {@link #firstShownFix} and {@link #lastShownFix} structures such that
+     * when any of them is accessed for the {@code competitor} passed as parameter then the {@code triggerable} will be
+     * triggered to ensure consistency and establish all invariants. This way, invariants may temporarily be left unmet
+     * which gives the UI a better chance of delaying particularly the tail updates. However, in case of read access the
+     * invariants all must be established, hence the trigger pattern.
+     */
+    private void registerTriggerable(final CompetitorDTO competitor, final Triggerable triggerable) {
+        final Trigger<Polyline> tailTrigger = tails.get(competitor);
+        if (tailTrigger != null) {
+            tailTrigger.register(triggerable);
+        }
+        registerIndexTrigger(triggerable, firstShownFix, competitor);
+        registerIndexTrigger(triggerable, lastShownFix, competitor);
+    }
     
     private void registerIndexTrigger(Triggerable triggerable, Map<CompetitorDTO, Trigger<Integer>> indexMap, CompetitorDTO competitor) {
         Trigger<Integer> firstShownFixTrigger = indexMap.get(competitor);
@@ -290,13 +305,14 @@ public class FixesAndTails {
         int indexOfLastShownFix = lastShownFix.get(competitorDTO).get() == null ? -1 : lastShownFix.get(competitorDTO).get();
         final Polyline tail = getTail(competitorDTO);
         int intoThisIndex = 0;
+        final Comparator<GPSFixDTOWithSpeedWindTackAndLegType> fixByTimePointComparator = new Comparator<GPSFixDTOWithSpeedWindTackAndLegType>() {
+            @Override
+            public int compare(GPSFixDTOWithSpeedWindTackAndLegType o1, GPSFixDTOWithSpeedWindTackAndLegType o2) {
+                return o1.timepoint.compareTo(o2.timepoint);
+            }
+        };
         for (GPSFixDTOWithSpeedWindTackAndLegType mergeThisFix : mergeThis) {
-            intoThisIndex = Collections.binarySearch(intoThis, mergeThisFix, new Comparator<GPSFixDTOWithSpeedWindTackAndLegType>() {
-                @Override
-                public int compare(GPSFixDTOWithSpeedWindTackAndLegType o1, GPSFixDTOWithSpeedWindTackAndLegType o2) {
-                    return o1.timepoint.compareTo(o2.timepoint);
-                }
-            });
+            intoThisIndex = Collections.binarySearch(intoThis, mergeThisFix, fixByTimePointComparator);
             if (intoThisIndex < 0) {
                 intoThisIndex = -intoThisIndex-1;
             }
@@ -322,6 +338,7 @@ public class FixesAndTails {
                                 tail.getPath().removeAt(finalIntoThisIndex - finalIndexOfFirstShownFix);
                             }
                         });
+                        registerTriggerable(competitorDTO, triggerable);
                         Timer timer = new TriggerableTimer(triggerable);
                         runDelayedOrImmediately(timer, (int) (timeForPositionTransitionMillis==-1?-1:timeForPositionTransitionMillis/2));
                     }
@@ -334,40 +351,47 @@ public class FixesAndTails {
                     intoThisIndex--;
                 }
             } else {
-                intoThis.add(intoThisIndex, mergeThisFix);
-                if (tail != null && intoThisIndex >= indexOfFirstShownFix && intoThisIndex <= indexOfLastShownFix) {
-                    // fix inserted at a position currently visualized by tail
-                    tail.getPath().insertAt(intoThisIndex - indexOfFirstShownFix, coordinateSystem.toLatLng(mergeThisFix.position));
-                }
-                if (intoThisIndex < indexOfFirstShownFix) {
-                    indexOfFirstShownFix++;
-                }
-                if (intoThisIndex <= indexOfLastShownFix) {
-                    indexOfLastShownFix++;
-                }
-                // If there is a fix prior to the one added and that prior fix was obtained by extrapolation, remove it now because
-                // extrapolated fixes can only be the last in the list
-                if (intoThisIndex > 0 && intoThis.get(intoThisIndex-1).extrapolated) {
-                    intoThis.remove(intoThisIndex-1);
-                    if (tail != null && intoThisIndex-1 >= indexOfFirstShownFix && intoThisIndex-1 <= indexOfLastShownFix) {
-                        final int finalIntoThisIndex = intoThisIndex;
-                        final int finalIndexOfFirstShownFix = indexOfFirstShownFix;
-                        Triggerable triggerable = new Triggerable(new Runnable() {
-                            @Override
-                            public void run() {
-                                tail.getPath().removeAt(finalIntoThisIndex-1 - finalIndexOfFirstShownFix);
-                            }
-                        });
-                        Timer timer = new TriggerableTimer(triggerable);
-                        runDelayedOrImmediately(timer, (int) (timeForPositionTransitionMillis==-1?-1:timeForPositionTransitionMillis/2));
+                // insert the fix only if it is not extrapolated or if the extrapolated fix is to be appended to the end (including
+                // being the only fix)
+                if (!mergeThisFix.extrapolated || intoThisIndex == intoThis.size()) {
+                    intoThis.add(intoThisIndex, mergeThisFix);
+                    if (tail != null && intoThisIndex >= indexOfFirstShownFix && intoThisIndex <= indexOfLastShownFix) {
+                        // fix inserted at a position currently visualized by tail
+                        tail.getPath().insertAt(intoThisIndex - indexOfFirstShownFix, coordinateSystem.toLatLng(mergeThisFix.position));
                     }
-                    if (intoThisIndex-1 < indexOfFirstShownFix) {
-                        indexOfFirstShownFix--;
+                    if (intoThisIndex < indexOfFirstShownFix) {
+                        indexOfFirstShownFix++;
                     }
-                    if (intoThisIndex-1 <= indexOfLastShownFix) {
-                        indexOfLastShownFix--;
+                    if (intoThisIndex <= indexOfLastShownFix) {
+                        indexOfLastShownFix++;
                     }
-                    intoThisIndex--;
+                    // If there is a fix prior to the one added and that prior fix was obtained by extrapolation, remove it now because
+                    // extrapolated fixes can only be the last in the list
+                    if (intoThisIndex > 0 && intoThis.get(intoThisIndex-1).extrapolated) {
+                        intoThis.remove(intoThisIndex-1);
+                        if (tail != null && intoThisIndex-1 >= indexOfFirstShownFix && intoThisIndex-1 <= indexOfLastShownFix) {
+                            final int finalIntoThisIndex = intoThisIndex;
+                            final int finalIndexOfFirstShownFix = indexOfFirstShownFix;
+                            Triggerable triggerable = new Triggerable(new Runnable() {
+                                @Override
+                                public void run() {
+                                    tail.getPath().removeAt(finalIntoThisIndex-1 - finalIndexOfFirstShownFix);
+                                }
+                            });
+                            registerTriggerable(competitorDTO, triggerable);
+                            Timer timer = new TriggerableTimer(triggerable);
+                            runDelayedOrImmediately(timer, (int) (timeForPositionTransitionMillis==-1?-1:timeForPositionTransitionMillis/2));
+                        }
+                        if (intoThisIndex-1 < indexOfFirstShownFix) {
+                            indexOfFirstShownFix--;
+                        }
+                        if (intoThisIndex-1 <= indexOfLastShownFix) {
+                            indexOfLastShownFix--;
+                        }
+                        intoThisIndex--;
+                    }
+                } else {
+                    intoThisIndex--; // to compensate for the following ++
                 }
             }
             intoThisIndex++;
@@ -519,13 +543,14 @@ public class FixesAndTails {
             Date toDate;
             Date timepointOfLastKnownFix = fixesForCompetitor == null ? null : getTimepointOfLastNonExtrapolated(fixesForCompetitor);
             Date timepointOfFirstKnownFix = fixesForCompetitor == null ? null : getTimepointOfFirstNonExtrapolated(fixesForCompetitor);
-            boolean overlap = false;
+            boolean overlap = timepointOfFirstKnownFix != null && timepointOfLastKnownFix != null &&
+                    new TimeRangeImpl(new MillisecondsTimePoint(tailstart), new MillisecondsTimePoint(upTo)).intersects(
+                            new TimeRangeImpl(new MillisecondsTimePoint(timepointOfFirstKnownFix), new MillisecondsTimePoint(timepointOfLastKnownFix)));
             if (fixesForCompetitor != null && timepointOfFirstKnownFix != null
                     && !tailstart.before(timepointOfFirstKnownFix) && timepointOfLastKnownFix != null
                     && !tailstart.after(timepointOfLastKnownFix)) {
                 // the beginning of what we need is contained in the interval we already have; skip what we already have
                 fromDate = new Date(timepointOfLastKnownFix.getTime()+1l); // "from" is "inclusive", so add 1ms to also skip the last fix we have
-                overlap = true;
             } else {
                 fromDate = tailstart;
             }
@@ -534,7 +559,6 @@ public class FixesAndTails {
                     && !upTo.after(timepointOfLastKnownFix)) {
                 // the end of what we need is contained in the interval we already have; skip what we already have
                 toDate = timepointOfFirstKnownFix;
-                overlap = true;
             } else {
                 toDate = upTo;
             }

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/server/SailingServiceImpl.java

@@ -77,7 +77,7 @@ import com.sap.sailing.domain.abstractlog.race.state.ReadonlyRaceState;
 import com.sap.sailing.domain.abstractlog.race.state.impl.ReadonlyRaceStateImpl;
 import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.FlagPoleState;
 import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.gate.ReadonlyGateStartRacingProcedure;
-import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.rrs26.ReadonlyRRS26RacingProcedure;
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.line.ConfigurableStartModeFlagRacingProcedure;
 import com.sap.sailing.domain.abstractlog.race.tracking.analyzing.impl.RaceLogTrackingStateAnalyzer;
 import com.sap.sailing.domain.abstractlog.regatta.RegattaLog;
 import com.sap.sailing.domain.abstractlog.regatta.RegattaLogEvent;
@@ -118,6 +118,7 @@ import com.sap.sailing.domain.base.SpeedWithBearingWithConfidence;
 import com.sap.sailing.domain.base.Waypoint;
 import com.sap.sailing.domain.base.configuration.DeviceConfiguration;
 import com.sap.sailing.domain.base.configuration.DeviceConfigurationMatcher;
+import com.sap.sailing.domain.base.configuration.RacingProcedureConfiguration;
 import com.sap.sailing.domain.base.configuration.RegattaConfiguration;
 import com.sap.sailing.domain.base.configuration.impl.DeviceConfigurationImpl;
 import com.sap.sailing.domain.base.configuration.impl.DeviceConfigurationMatcherSingle;
@@ -126,7 +127,10 @@ import com.sap.sailing.domain.base.configuration.impl.GateStartConfigurationImpl
 import com.sap.sailing.domain.base.configuration.impl.LeagueConfigurationImpl;
 import com.sap.sailing.domain.base.configuration.impl.RRS26ConfigurationImpl;
 import com.sap.sailing.domain.base.configuration.impl.RacingProcedureConfigurationImpl;
+import com.sap.sailing.domain.base.configuration.impl.RacingProcedureWithConfigurableStartModeFlagConfigurationImpl;
 import com.sap.sailing.domain.base.configuration.impl.RegattaConfigurationImpl;
+import com.sap.sailing.domain.base.configuration.impl.SWCConfigurationImpl;
+import com.sap.sailing.domain.base.configuration.procedures.ConfigurableStartModeFlagRacingProcedureConfiguration;
 import com.sap.sailing.domain.base.impl.BoatImpl;
 import com.sap.sailing.domain.base.impl.CourseDataImpl;
 import com.sap.sailing.domain.base.impl.CourseImpl;
@@ -309,6 +313,7 @@ import com.sap.sailing.gwt.ui.shared.CoursePositionsDTO;
 import com.sap.sailing.gwt.ui.shared.DeviceConfigurationDTO;
 import com.sap.sailing.gwt.ui.shared.DeviceConfigurationDTO.RegattaConfigurationDTO;
 import com.sap.sailing.gwt.ui.shared.DeviceConfigurationDTO.RegattaConfigurationDTO.RacingProcedureConfigurationDTO;
+import com.sap.sailing.gwt.ui.shared.DeviceConfigurationDTO.RegattaConfigurationDTO.RacingProcedureWithConfigurableStartModeFlagConfigurationDTO;
 import com.sap.sailing.gwt.ui.shared.DeviceConfigurationMatcherDTO;
 import com.sap.sailing.gwt.ui.shared.DeviceIdentifierDTO;
 import com.sap.sailing.gwt.ui.shared.DeviceMappingDTO;
@@ -332,7 +337,7 @@ import com.sap.sailing.gwt.ui.shared.RaceGroupDTO;
 import com.sap.sailing.gwt.ui.shared.RaceGroupSeriesDTO;
 import com.sap.sailing.gwt.ui.shared.RaceInfoDTO;
 import com.sap.sailing.gwt.ui.shared.RaceInfoDTO.GateStartInfoDTO;
-import com.sap.sailing.gwt.ui.shared.RaceInfoDTO.RRS26InfoDTO;
+import com.sap.sailing.gwt.ui.shared.RaceInfoDTO.LineStartInfoDTO;
 import com.sap.sailing.gwt.ui.shared.RaceInfoDTO.RaceInfoExtensionDTO;
 import com.sap.sailing.gwt.ui.shared.RaceLogDTO;
 import com.sap.sailing.gwt.ui.shared.RaceLogEventDTO;
@@ -981,8 +986,9 @@ public class SailingServiceImpl extends ProxiedRemoteServiceServlet implements S
             info = new GateStartInfoDTO(gateStart.getPathfinder(), gateStart.getGateLaunchStopTime());
             break;
         case RRS26:
-            ReadonlyRRS26RacingProcedure rrs26 = state.getTypedReadonlyRacingProcedure();
-            info = new RRS26InfoDTO(rrs26.getStartModeFlag());
+        case SWC:
+            ConfigurableStartModeFlagRacingProcedure linestart = state.getTypedReadonlyRacingProcedure();
+            info = new LineStartInfoDTO(linestart.getStartModeFlag());
         case UNKNOWN:
         default:
             break;
@@ -1720,12 +1726,13 @@ public class SailingServiceImpl extends ProxiedRemoteServiceServlet implements S
      *            date provided as value
      * @param to
      *            for the list of competitors provided as keys (expected to be equal to the set of competitors used as
-     *            keys in the <code>from</code> parameter, requests the GPS fixes up to but excluding the date provided
-     *            as value
+     *            keys in the <code>from</code> parameter, requests the GPS fixes up to but excluding (except
+     *            {@code extrapolate} is {@code true}) the date provided as value
      * @param extrapolate
-     *            if <code>true</code> and no (exact or interpolated) position is known for <code>date</code>, the last
+     *            if <code>true</code> and no (exact or interpolated) position is known for <code>to</code>, the last
      *            entry returned in the list of GPS fixes will be obtained by extrapolating from the competitors last
-     *            known position before <code>date</code> and the estimated speed.
+     *            known position at <code>to</code> and the estimated speed. With this, the {@code to} time point is no
+     *            longer exclusive.
      * @return a map where for each competitor participating in the race the list of GPS fixes in increasing
      *         chronological order is provided. The last one is the last position at or before <code>date</code>.
      */
@@ -1753,7 +1760,8 @@ public class SailingServiceImpl extends ProxiedRemoteServiceServlet implements S
                         Iterator<GPSFixMoving> fixIter = track.getFixesIterator(fromTimePoint, /* inclusive */true);
                         while (fixIter.hasNext()) {
                             GPSFixMoving fix = fixIter.next();
-                            if (fix.getTimePoint().before(toTimePointExcluding)) {
+                            if (fix.getTimePoint().before(toTimePointExcluding) ||
+                                    (extrapolate && fix.getTimePoint().equals(toTimePointExcluding))) {
                                 if (logger.isLoggable(Level.FINEST)) {
                                     logger.finest(""+competitor.getName()+": " + fix);
                                 }
@@ -1817,7 +1825,7 @@ public class SailingServiceImpl extends ProxiedRemoteServiceServlet implements S
                             if (fixIter.hasNext()) {
                                 fix = fixIter.next();
                             } else {
-                                // check if fix was at date and if extrapolation is requested
+                                // check if fix was at date and if extrapolation is requested; 
                                 if (!fix.getTimePoint().equals(toTimePointExcluding) && extrapolate) {
                                     Position position = track.getEstimatedPosition(toTimePointExcluding, extrapolate);
                                     Wind wind2 = trackedRace.getWind(position, toTimePointExcluding);
@@ -4854,39 +4862,44 @@ public class SailingServiceImpl extends ProxiedRemoteServiceServlet implements S
         
         if (configuration.getRRS26Configuration() != null) {
             dto.rrs26Configuration = new DeviceConfigurationDTO.RegattaConfigurationDTO.RRS26ConfigurationDTO();
-            dto.rrs26Configuration.classFlag = configuration.getRRS26Configuration().getClassFlag();
-            dto.rrs26Configuration.hasIndividualRecall = configuration.getRRS26Configuration().hasIndividualRecall();
-            dto.rrs26Configuration.isResultEntryEnabled = configuration.getRRS26Configuration().isResultEntryEnabled();
-            dto.rrs26Configuration.startModeFlags = configuration.getRRS26Configuration().getStartModeFlags();
+            copyBasicRacingProcedureProperties(configuration.getRRS26Configuration(), dto.rrs26Configuration);
+            copyRacingProcedureWithConfigurableStartModeFlagProperties(configuration.getRRS26Configuration(), dto.rrs26Configuration);
+        }
+        if (configuration.getSWCConfiguration() != null) {
+            dto.swcStartConfiguration = new DeviceConfigurationDTO.RegattaConfigurationDTO.SWCStartConfigurationDTO();
+            copyBasicRacingProcedureProperties(configuration.getSWCConfiguration(), dto.swcStartConfiguration);
+            copyRacingProcedureWithConfigurableStartModeFlagProperties(configuration.getSWCConfiguration(), dto.swcStartConfiguration);
         }
         if (configuration.getGateStartConfiguration() != null) {
             dto.gateStartConfiguration = new DeviceConfigurationDTO.RegattaConfigurationDTO.GateStartConfigurationDTO();
-            dto.gateStartConfiguration.classFlag = configuration.getGateStartConfiguration().getClassFlag();
-            dto.gateStartConfiguration.hasIndividualRecall = configuration.getGateStartConfiguration().hasIndividualRecall();
-            dto.gateStartConfiguration.isResultEntryEnabled = configuration.getGateStartConfiguration().isResultEntryEnabled();
+            copyBasicRacingProcedureProperties(configuration.getGateStartConfiguration(), dto.gateStartConfiguration);
             dto.gateStartConfiguration.hasPathfinder = configuration.getGateStartConfiguration().hasPathfinder();
             dto.gateStartConfiguration.hasAdditionalGolfDownTime = configuration.getGateStartConfiguration().hasAdditionalGolfDownTime();
         }
         if (configuration.getESSConfiguration() != null) {
             dto.essConfiguration = new DeviceConfigurationDTO.RegattaConfigurationDTO.ESSConfigurationDTO();
-            dto.essConfiguration.classFlag = configuration.getESSConfiguration().getClassFlag();
-            dto.essConfiguration.hasIndividualRecall = configuration.getESSConfiguration().hasIndividualRecall();
-            dto.essConfiguration.isResultEntryEnabled = configuration.getESSConfiguration().isResultEntryEnabled();
+            copyBasicRacingProcedureProperties(configuration.getESSConfiguration(), dto.essConfiguration);
         }
         if (configuration.getBasicConfiguration() != null) {
             dto.basicConfiguration = new DeviceConfigurationDTO.RegattaConfigurationDTO.RacingProcedureConfigurationDTO();
-            dto.basicConfiguration.classFlag = configuration.getBasicConfiguration().getClassFlag();
-            dto.basicConfiguration.hasIndividualRecall = configuration.getBasicConfiguration().hasIndividualRecall();
-            dto.basicConfiguration.isResultEntryEnabled = configuration.getBasicConfiguration().isResultEntryEnabled();
+            copyBasicRacingProcedureProperties(configuration.getBasicConfiguration(), dto.basicConfiguration);
         }
         if (configuration.getLeagueConfiguration() != null) {
             dto.leagueConfiguration = new DeviceConfigurationDTO.RegattaConfigurationDTO.LeagueConfigurationDTO();
-            dto.leagueConfiguration.classFlag = configuration.getLeagueConfiguration().getClassFlag();
-            dto.leagueConfiguration.hasIndividualRecall = configuration.getLeagueConfiguration().hasIndividualRecall();
-            dto.leagueConfiguration.isResultEntryEnabled = configuration.getLeagueConfiguration().isResultEntryEnabled();
+            copyBasicRacingProcedureProperties(configuration.getLeagueConfiguration(), dto.leagueConfiguration);
         }
         return dto;
     }
+    
+    private void copyBasicRacingProcedureProperties(RacingProcedureConfiguration configuration, final RacingProcedureConfigurationDTO racingProcedureConfigurationDTO) {
+        racingProcedureConfigurationDTO.classFlag = configuration.getClassFlag();
+        racingProcedureConfigurationDTO.hasIndividualRecall = configuration.hasIndividualRecall();
+        racingProcedureConfigurationDTO.isResultEntryEnabled = configuration.isResultEntryEnabled();
+    }
+
+    private void copyRacingProcedureWithConfigurableStartModeFlagProperties(ConfigurableStartModeFlagRacingProcedureConfiguration configuration, final RacingProcedureWithConfigurableStartModeFlagConfigurationDTO racingProcedureConfigurationDTO) {
+        racingProcedureConfigurationDTO.startModeFlags = configuration.getStartModeFlags();
+    }
 
     private DeviceConfigurationImpl convertToDeviceConfiguration(DeviceConfigurationDTO dto) {
         DeviceConfigurationImpl configuration = new DeviceConfigurationImpl(convertToRegattaConfiguration(dto.regattaConfiguration));
@@ -4906,9 +4919,15 @@ public class SailingServiceImpl extends ProxiedRemoteServiceServlet implements S
         if (dto.rrs26Configuration != null) {
             RRS26ConfigurationImpl config = new RRS26ConfigurationImpl();
             applyGeneralRacingProcedureConfigProperties(dto.rrs26Configuration, config);
-            config.setStartModeFlags(dto.rrs26Configuration.startModeFlags);
+            applyRacingProcedureWithConfigurableStartModeFlagConfigProperties(dto.rrs26Configuration, config);
             configuration.setRRS26Configuration(config);
         }
+        if (dto.swcStartConfiguration != null) {
+            SWCConfigurationImpl config = new SWCConfigurationImpl();
+            applyGeneralRacingProcedureConfigProperties(dto.swcStartConfiguration, config);
+            applyRacingProcedureWithConfigurableStartModeFlagConfigProperties(dto.swcStartConfiguration, config);
+            configuration.setSWCConfiguration(config);
+        }
         if (dto.gateStartConfiguration != null) {
             GateStartConfigurationImpl config = new GateStartConfigurationImpl();
             applyGeneralRacingProcedureConfigProperties(dto.gateStartConfiguration, config);
@@ -4941,6 +4960,12 @@ public class SailingServiceImpl extends ProxiedRemoteServiceServlet implements S
         config.setResultEntryEnabled(racingProcedureConfigurationDTO.isResultEntryEnabled);
     }
 
+    private void applyRacingProcedureWithConfigurableStartModeFlagConfigProperties(
+            RacingProcedureWithConfigurableStartModeFlagConfigurationDTO racingProcedureConfigurationDTO,
+            RacingProcedureWithConfigurableStartModeFlagConfigurationImpl config) {
+        config.setStartModeFlags(racingProcedureConfigurationDTO.startModeFlags);
+    }
+    
     @Override
     public boolean setStartTimeAndProcedure(RaceLogSetStartTimeAndProcedureDTO dto) {
         TimePoint newStartTime = getService().setStartTimeAndProcedure(dto.leaderboardName, dto.raceColumnName, 

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/shared/DeviceConfigurationDTO.java

@@ -10,10 +10,16 @@ import com.sap.sailing.domain.common.racelog.RacingProcedureType;
 public class DeviceConfigurationDTO implements IsSerializable {
     
     public static class RegattaConfigurationDTO implements IsSerializable {
-        public static class RRS26ConfigurationDTO extends RacingProcedureConfigurationDTO {
+        public static class RacingProcedureWithConfigurableStartModeFlagConfigurationDTO extends RacingProcedureConfigurationDTO {
             public List<Flags> startModeFlags;
         }
         
+        public static class RRS26ConfigurationDTO extends RacingProcedureWithConfigurableStartModeFlagConfigurationDTO {
+        }
+
+        public static class SWCStartConfigurationDTO extends RacingProcedureWithConfigurableStartModeFlagConfigurationDTO {
+        }
+
         public static class GateStartConfigurationDTO extends RacingProcedureConfigurationDTO {
             public Boolean hasPathfinder;
             public Boolean hasAdditionalGolfDownTime;
@@ -36,6 +42,7 @@ public class DeviceConfigurationDTO implements IsSerializable {
         public CourseDesignerMode defaultCourseDesignerMode;
         
         public RRS26ConfigurationDTO rrs26Configuration;
+        public SWCStartConfigurationDTO swcStartConfiguration;
         public GateStartConfigurationDTO gateStartConfiguration;
         public ESSConfigurationDTO essConfiguration;
         public RacingProcedureConfigurationDTO basicConfiguration;

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/shared/RaceInfoDTO.java

@@ -26,13 +26,13 @@ public class RaceInfoDTO implements IsSerializable {
         }
     }
     
-    public static class RRS26InfoDTO implements RaceInfoExtensionDTO {
+    public static class LineStartInfoDTO implements RaceInfoExtensionDTO {
         public Flags startModeFlag;
         
         // for GWT serialization
-        public RRS26InfoDTO() { }
+        public LineStartInfoDTO() { }
         
-        public RRS26InfoDTO(Flags startMode) {
+        public LineStartInfoDTO(Flags startMode) {
             this.startModeFlag = startMode;
         }
     }

java/com.sap.sailing.gwt.ui/src/main/resources/com/sap/sailing/gwt/home/solutions/RaceCommitteeAppNotes.html

@@ -10,6 +10,7 @@
 			<li>The protest time is now more configurable. You can set the start time and
 			    the duration. The default protest duration is 90 min and the last duration is
 			    stored in the settings, so you don't need to change it the next time.</li>
+			<li>If the protest time is set for a race, it is shown in the race summary view.</li>
 		</ul>
 
 		<h5 class="articleSubheadline">October 2016</h5>

mobile/com.sap.sailing.android.tracking.app/res/values/preferences.xml

@@ -16,7 +16,7 @@
     <string name="preference_energy_saving_sending_interval_summary">Choose a value as high as possible to preserve battery life while still maintaining a reasonable live experience, depending on your use case.</string>
 
     <string name="preference_energy_saving_sending_interval_message">GPS updates will be sent to the server%1$s %2$s.</string>
-    <string name="preference_energy_saving_sending_interval_message_key">msgSndIntMessage</string>
+    <string name="preference_energy_saving_sending_interval_message_key" translatable="false">msgSndIntMessage</string>
     <string name="preference_energy_saving_sending_interval_message_every">every</string>
     <string-array name="preference_energy_saving_sending_interval_entries">
     	<item>immediately</item>

mobile/com.sap.sailing.racecommittee.app/res/layout/race_summary.xml

@@ -1,6 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<RelativeLayout
-    xmlns:android="http://schemas.android.com/apk/res/android"
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:tools="http://schemas.android.com/tools"
     android:layout_width="match_parent"
     android:layout_height="match_parent">
@@ -8,6 +7,9 @@
     <ScrollView
         android:layout_width="match_parent"
         android:layout_height="match_parent"
+        android:layout_alignParentLeft="true"
+        android:layout_alignParentStart="true"
+        android:layout_alignParentTop="true"
         android:background="?attr/sap_gray_black_30">
 
         <LinearLayout
@@ -29,20 +31,20 @@
                     android:layout_centerInParent="true"
                     android:text="@string/race_summary_title"
                     android:textColor="?attr/white"
-                    android:textSize="@dimen/finished_header_text_size"/>
+                    android:textSize="@dimen/finished_header_text_size" />
             </RelativeLayout>
 
             <ImageView
                 android:layout_width="match_parent"
                 android:layout_height="@dimen/thin_line"
                 android:layout_marginBottom="@dimen/default_margin_half"
-                android:background="?attr/black"/>
+                android:background="?attr/black" />
 
             <LinearLayout
                 android:layout_width="match_parent"
                 android:layout_height="wrap_content"
-                android:paddingTop="@dimen/finished_line_padding_half"
-                android:paddingBottom="@dimen/finished_line_padding_half">
+                android:paddingBottom="@dimen/finished_line_padding_half"
+                android:paddingTop="@dimen/finished_line_padding_half">
 
                 <TextView
                     android:layout_width="0dp"
@@ -51,7 +53,7 @@
                     android:layout_weight="15"
                     android:text="@string/race_summary_start"
                     android:textColor="?attr/white"
-                    android:textSize="@dimen/finished_default_text_size"/>
+                    android:textSize="@dimen/finished_default_text_size" />
 
                 <ImageView
                     android:id="@+id/edit_race_start_time"
@@ -61,7 +63,7 @@
                     android:layout_marginLeft="@dimen/default_margin_half"
                     android:src="?attr/create"
                     android:visibility="invisible"
-                    tools:visibility="visible"/>
+                    tools:visibility="visible" />
 
                 <TextView
                     android:id="@+id/race_start_time"
@@ -69,22 +71,22 @@
                     android:layout_height="wrap_content"
                     android:layout_gravity="center_vertical"
                     android:layout_weight="8"
+                    android:gravity="center_horizontal"
                     android:textColor="?attr/white"
                     android:textSize="@dimen/finished_default_text_size"
-                    tools:text="11:00:00"
-                    android:gravity="center_horizontal" />
+                    tools:text="11:00:00" />
 
                 <View
                     android:layout_width="0dp"
                     android:layout_height="match_parent"
-                    android:layout_weight="10"/>
+                    android:layout_weight="10" />
             </LinearLayout>
 
             <LinearLayout
                 android:layout_width="match_parent"
                 android:layout_height="wrap_content"
-                android:paddingTop="@dimen/finished_line_padding_half"
-                android:paddingBottom="@dimen/finished_line_padding_half">
+                android:paddingBottom="@dimen/finished_line_padding_half"
+                android:paddingTop="@dimen/finished_line_padding_half">
 
                 <TextView
                     android:layout_width="0dp"
@@ -93,7 +95,7 @@
                     android:layout_weight="15"
                     android:text="@string/race_summary_finish_begin"
                     android:textColor="?attr/white"
-                    android:textSize="@dimen/finished_default_text_size"/>
+                    android:textSize="@dimen/finished_default_text_size" />
 
                 <ImageView
                     android:id="@+id/edit_race_finish_begin_time"
@@ -102,7 +104,7 @@
                     android:layout_gravity="center_vertical"
                     android:layout_marginLeft="@dimen/default_margin_half"
                     android:src="?attr/create"
-                    android:visibility="visible"/>
+                    android:visibility="visible" />
 
                 <TextView
                     android:id="@+id/race_finish_begin_time"
@@ -113,7 +115,7 @@
                     android:gravity="center_horizontal"
                     android:textColor="?attr/white"
                     android:textSize="@dimen/finished_default_text_size"
-                    tools:text="11:12:18"/>
+                    tools:text="11:12:18" />
 
                 <TextView
                     android:id="@+id/race_finish_begin_duration"
@@ -124,7 +126,7 @@
                     android:gravity="right"
                     android:textColor="?attr/white"
                     android:textSize="@dimen/finished_default_text_size"
-                    tools:text="18h 12' 18''"/>
+                    tools:text="18h 12' 18''" />
             </LinearLayout>
 
             <LinearLayout
@@ -140,7 +142,7 @@
                     android:layout_weight="15"
                     android:text="@string/race_summary_finish_end"
                     android:textColor="?attr/white"
-                    android:textSize="@dimen/finished_default_text_size"/>
+                    android:textSize="@dimen/finished_default_text_size" />
 
                 <ImageView
                     android:id="@+id/edit_race_finish_end_time"
@@ -149,7 +151,7 @@
                     android:layout_gravity="center_vertical"
                     android:layout_marginLeft="@dimen/default_margin_half"
                     android:src="?attr/create"
-                    android:visibility="visible"/>
+                    android:visibility="visible" />
 
                 <TextView
                     android:id="@+id/race_finish_end_time"
@@ -157,10 +159,10 @@
                     android:layout_height="wrap_content"
                     android:layout_gravity="center_vertical"
                     android:layout_weight="8"
+                    android:gravity="center_horizontal"
                     android:textColor="?attr/white"
                     android:textSize="@dimen/finished_default_text_size"
-                    tools:text="11:16:36"
-                    android:gravity="center_horizontal" />
+                    tools:text="11:16:36" />
 
                 <TextView
                     android:id="@+id/race_finish_end_duration"
@@ -171,7 +173,7 @@
                     android:gravity="right"
                     android:textColor="?attr/white"
                     android:textSize="@dimen/finished_default_text_size"
-                    tools:text="0h 16' 36''"/>
+                    tools:text="0h 16' 36''" />
             </LinearLayout>
 
             <LinearLayout
@@ -187,7 +189,7 @@
                     android:layout_weight="15"
                     android:text="@string/race_summary_finish_duration"
                     android:textColor="?attr/white"
-                    android:textSize="@dimen/finished_default_text_size"/>
+                    android:textSize="@dimen/finished_default_text_size" />
 
                 <TextView
                     android:id="@+id/race_finish_duration"
@@ -198,7 +200,108 @@
                     android:gravity="right"
                     android:textColor="?attr/white"
                     android:textSize="@dimen/finished_default_text_size"
-                    tools:text="0h 04' 18''"/>
+                    tools:text="0h 04' 18''" />
+            </LinearLayout>
+
+            <LinearLayout
+                android:id="@+id/region_protest"
+                android:layout_width="match_parent"
+                android:layout_height="match_parent"
+                android:orientation="vertical"
+                android:visibility="gone"
+                tools:visibility="visible">
+
+                <ImageView
+                    android:layout_width="match_parent"
+                    android:layout_height="@dimen/thin_line"
+                    android:layout_marginBottom="@dimen/default_margin_half"
+                    android:layout_marginTop="@dimen/default_margin_half"
+                    android:background="?attr/black" />
+
+                <LinearLayout
+                    android:id="@+id/protest_start"
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content"
+                    android:orientation="horizontal"
+                    android:paddingBottom="@dimen/finished_line_padding_half"
+                    android:paddingTop="@dimen/finished_line_padding_half">
+
+                    <TextView
+                        android:layout_width="0dp"
+                        android:layout_height="wrap_content"
+                        android:layout_weight="15"
+                        android:text="@string/protest_time_start"
+                        android:textColor="?attr/white"
+                        android:textSize="@dimen/finished_default_text_size" />
+
+                    <Space
+                        android:layout_width="24dp"
+                        android:layout_height="24dp"
+                        android:layout_marginLeft="@dimen/default_margin_half"
+                        android:layout_gravity="center_vertical" />
+
+                    <TextView
+                        android:id="@+id/protest_time_start"
+                        android:layout_width="0dp"
+                        android:layout_height="wrap_content"
+                        android:layout_gravity="center_vertical"
+                        android:layout_weight="8"
+                        android:gravity="center_horizontal"
+                        android:textColor="?attr/white"
+                        android:textSize="@dimen/finished_default_text_size"
+                        tools:text="12:12:23" />
+
+                    <Space
+                        android:layout_width="0dp"
+                        android:layout_height="wrap_content"
+                        android:layout_gravity="center_vertical"
+                        android:layout_weight="10" />
+                </LinearLayout>
+
+                <LinearLayout
+                    android:id="@+id/protest_end"
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content"
+                    android:orientation="horizontal"
+                    android:paddingBottom="@dimen/finished_line_padding_half"
+                    android:paddingTop="@dimen/finished_line_padding_half">
+
+                    <TextView
+                        android:layout_width="0dp"
+                        android:layout_height="wrap_content"
+                        android:layout_weight="15"
+                        android:text="@string/protest_time_end"
+                        android:textColor="?attr/white"
+                        android:textSize="@dimen/finished_default_text_size" />
+
+                    <Space
+                        android:layout_width="24dp"
+                        android:layout_height="24dp"
+                        android:layout_marginLeft="@dimen/default_margin_half"
+                        android:layout_gravity="center_vertical" />
+
+                    <TextView
+                        android:id="@+id/protest_time_end"
+                        android:layout_width="0dp"
+                        android:layout_height="wrap_content"
+                        android:layout_gravity="center_vertical"
+                        android:layout_weight="8"
+                        android:gravity="center_horizontal"
+                        android:textColor="?attr/white"
+                        android:textSize="@dimen/finished_default_text_size"
+                        tools:text="12:12:23" />
+
+                    <TextView
+                        android:id="@+id/protest_time_duration"
+                        android:layout_width="0dp"
+                        android:layout_height="wrap_content"
+                        android:layout_gravity="center_vertical"
+                        android:layout_weight="10"
+                        android:gravity="right"
+                        android:textColor="?attr/white"
+                        android:textSize="@dimen/finished_default_text_size"
+                        tools:text="12' 12" />
+                </LinearLayout>
             </LinearLayout>
 
             <LinearLayout
@@ -212,7 +315,7 @@
                     android:layout_height="@dimen/thin_line"
                     android:layout_marginBottom="@dimen/default_margin_half"
                     android:layout_marginTop="@dimen/default_margin_half"
-                    android:background="?attr/black"/>
+                    android:background="?attr/black" />
 
                 <LinearLayout
                     android:layout_width="match_parent"
@@ -227,7 +330,7 @@
                         android:layout_weight="3"
                         android:text="@string/race_summary_wind_direction"
                         android:textColor="?attr/white"
-                        android:textSize="@dimen/finished_default_text_size"/>
+                        android:textSize="@dimen/finished_default_text_size" />
 
                     <TextView
                         android:id="@+id/wind_direction"
@@ -238,7 +341,7 @@
                         android:gravity="right"
                         android:textColor="?attr/white"
                         android:textSize="@dimen/finished_default_text_size"
-                        tools:text="from 192°"/>
+                        tools:text="from 192°" />
                 </LinearLayout>
 
                 <LinearLayout
@@ -254,7 +357,8 @@
                         android:layout_weight="3"
                         android:text="@string/race_summary_wind_speed"
                         android:textColor="?attr/white"
-                        android:textSize="@dimen/finished_default_text_size"/>
+                        android:textSize="@dimen/finished_default_text_size"
+                        android:id="@+id/textView" />
 
                     <TextView
                         android:id="@+id/wind_speed"
@@ -265,7 +369,7 @@
                         android:gravity="right"
                         android:textColor="?attr/white"
                         android:textSize="@dimen/finished_default_text_size"
-                        tools:text="6.5 kts"/>
+                        tools:text="6.5 kts" />
                 </LinearLayout>
             </LinearLayout>
 
@@ -280,13 +384,13 @@
                     android:layout_height="@dimen/thin_line"
                     android:layout_marginBottom="@dimen/default_margin_half"
                     android:layout_marginTop="@dimen/default_margin_half"
-                    android:background="?attr/black"/>
+                    android:background="?attr/black" />
 
                 <LinearLayout
                     android:layout_width="match_parent"
                     android:layout_height="wrap_content"
-                    android:paddingTop="@dimen/finished_line_padding_half"
-                    android:paddingBottom="@dimen/finished_line_padding_half">
+                    android:paddingBottom="@dimen/finished_line_padding_half"
+                    android:paddingTop="@dimen/finished_line_padding_half">
 
                     <TextView
                         android:layout_width="wrap_content"
@@ -294,7 +398,7 @@
                         android:layout_gravity="center_vertical"
                         android:text="@string/race_summary_individual_recalls"
                         android:textColor="?attr/white"
-                        android:textSize="@dimen/finished_default_text_size"/>
+                        android:textSize="@dimen/finished_default_text_size" />
 
                     <TextView
                         android:layout_width="match_parent"
@@ -303,7 +407,8 @@
                         android:gravity="right"
                         android:textColor="?attr/white"
                         android:textSize="@dimen/finished_default_text_size"
-                        tools:text="AUT 553  GER 766  ITA 912"/>
+                        tools:text="AUT 553  GER 766  ITA 912"
+                        android:id="@+id/textView2" />
                 </LinearLayout>
             </LinearLayout>
         </LinearLayout>

mobile/com.sap.sailing.racecommittee.app/res/values-de/strings.xml

@@ -199,7 +199,7 @@
     <string name="gate_launch_stops_after">Gate Launch stoppt nach %dmin</string>
     <string name="override_default_course_designer_type_select_header">Kursdesigner</string>
     <string name="settings_course_designer_by_name_course_names_header">Kursnamen</string>
-    <string name="preference_racing_procedure_rrs26_startmode_flags_header">Startmodus Flaggen</string>
+    <string name="preference_racing_procedure_startmode_flags_header">Startmodus Flaggen</string>
     <string name="preference_racing_procedure_classflag_header">Klassenflagge</string>
     <string name="preference_racing_procedure_hasxray_header">Einzelrückruf</string>
     <string name="preference_racing_procedure_hasxray_description">Diese Option aktiviert den Einzelrückruf</string>
@@ -381,6 +381,8 @@
     <string name="finished_text_01">Bitte evaluieren und übermitteln Sie die Zusammenfassung des Rennens.</string>
     <string name="finished_text_02">Ihre Zusammenfassung wurde veröffentlicht. Änderungen müssen erneut gesendet werden.</string>
     <string name="protest_time">Protestzeit</string>
+    <string name="protest_time_start">Start der Protestzeit</string>
+    <string name="protest_time_end">Ende der Protestzeit</string>
     <string name="finished_duration">#TIME# min</string>
     <string name="no_camera">Keine Kamera-App gefunden</string>
     <string name="delete_file">Das löscht das Foto</string>

mobile/com.sap.sailing.racecommittee.app/res/values/preferences.xml

@@ -61,6 +61,19 @@
         <item>UNIFORM</item>
         <item>ZULU</item>
     </string-array>
+    <string name="preference_racing_procedure_swc_classflag_key" translatable="false">swcClassFlag</string>
+    <string name="preference_racing_procedure_swc_hasxray_key" translatable="false">swcIndividualRecall</string>
+    <bool name="preference_racing_procedure_swc_hasxray_default">true</bool>
+    <string name="preference_racing_procedure_swc_resultentryenabled_key" translatable="false">swcResultEntryEnabled</string>
+    <bool name="preference_racing_procedure_swc_resultentryenabled_default">false</bool>
+    <string name="preference_racing_procedure_swc_startmode_flags_key" translatable="false">swcStartmodeFlags</string>
+    <string-array name="preference_racing_procedure_swc_startmode_flags_default">
+        <item>PAPA</item>
+        <item>INDIA</item>
+        <item>BLACK</item>
+        <item>UNIFORM</item>
+        <item>ZULU</item>
+    </string-array>
     <string name="preference_racing_procedure_gatestart_classflag_key" translatable="false">gateStartClassFlag</string>
     <string name="preference_racing_procedure_gatestart_hasxray_key" translatable="false">gateStartIndividualRecall</string>
     <bool name="preference_racing_procedure_gatestart_hasxray_default">false</bool>

mobile/com.sap.sailing.racecommittee.app/res/values/strings.xml

@@ -207,7 +207,7 @@
     <string name="settings_category_course_designer">Course Designer Configuration</string>
     <string name="override_default_course_designer_type_select_header">Course Designer Type</string>
     <string name="settings_course_designer_by_name_course_names_header">Course Names</string>
-    <string name="preference_racing_procedure_rrs26_startmode_flags_header">Startmode Flags</string>
+    <string name="preference_racing_procedure_startmode_flags_header">Startmode Flags</string>
     <string name="preference_racing_procedure_classflag_header">Class Flag</string>
     <string name="preference_racing_procedure_hasxray_header">Individual Recall</string>
     <string name="preference_racing_procedure_hasxray_description">Activate this option to enable individual recall</string>
@@ -406,6 +406,8 @@
     <string name="finished_text_02">Your evaluation has been published. Changes need to be resubmitted in orde to take effect.</string>
 
     <string name="protest_time">Protest Time</string>
+    <string name="protest_time_start">Start Protest Time</string>
+    <string name="protest_time_end">End Protest Time</string>
     <string name="degrees">Degrees</string>
 
     <string name="no_camera">No Camera App found</string>

mobile/com.sap.sailing.racecommittee.app/res/xml/preference_regatta_defaults.xml

@@ -72,7 +72,35 @@
             android:defaultValue="@array/preference_racing_procedure_rrs26_startmode_flags_default"
             android:key="@string/preference_racing_procedure_rrs26_startmode_flags_key"
             android:summary="@string/empty"
-            android:title="@string/preference_racing_procedure_rrs26_startmode_flags_header" />
+            android:title="@string/preference_racing_procedure_startmode_flags_header" />
+
+    </PreferenceCategory>
+
+    <PreferenceCategory android:title="SWC Start">
+
+        <ListPreference
+            android:defaultValue="@string/preference_racing_procedure_classflag_default"
+            android:key="@string/preference_racing_procedure_swc_classflag_key"
+            android:summary="@string/empty"
+            android:title="@string/preference_racing_procedure_classflag_header" />
+
+        <CheckBoxPreference
+            android:defaultValue="@bool/preference_racing_procedure_swc_hasxray_default"
+            android:key="@string/preference_racing_procedure_swc_hasxray_key"
+            android:summary="@string/preference_racing_procedure_hasxray_description"
+            android:title="@string/preference_racing_procedure_hasxray_header" />
+
+        <CheckBoxPreference
+            android:defaultValue="@bool/preference_racing_procedure_swc_resultentryenabled_default"
+            android:key="@string/preference_racing_procedure_swc_resultentryenabled_key"
+            android:summary="@string/preference_racing_procedure_resultentryenabled_description"
+            android:title="@string/preference_racing_procedure_resultentryenabled_header"/>
+
+        <com.sap.sailing.racecommittee.app.ui.views.FixedMultiSelectListPreference
+            android:defaultValue="@array/preference_racing_procedure_swc_startmode_flags_default"
+            android:key="@string/preference_racing_procedure_swc_startmode_flags_key"
+            android:summary="@string/empty"
+            android:title="@string/preference_racing_procedure_startmode_flags_header" />
 
     </PreferenceCategory>
 

mobile/com.sap.sailing.racecommittee.app/src/com/sap/sailing/racecommittee/app/AppPreferences.java

@@ -223,6 +223,8 @@ public class AppPreferences {
         switch (type) {
             case RRS26:
                 return key(R.string.preference_racing_procedure_rrs26_classflag_key);
+            case SWC:
+                return key(R.string.preference_racing_procedure_swc_classflag_key);
             case GateStart:
                 return key(R.string.preference_racing_procedure_gatestart_classflag_key);
             case ESS:
@@ -245,6 +247,8 @@ public class AppPreferences {
         switch (type) {
             case RRS26:
                 return key(R.string.preference_racing_procedure_rrs26_hasxray_key);
+            case SWC:
+                return key(R.string.preference_racing_procedure_swc_hasxray_key);
             case GateStart:
                 return key(R.string.preference_racing_procedure_gatestart_hasxray_key);
             case ESS:
@@ -267,6 +271,8 @@ public class AppPreferences {
         switch (type) {
         case RRS26:
             return key(R.string.preference_racing_procedure_rrs26_resultentryenabled_key);
+        case SWC:
+            return key(R.string.preference_racing_procedure_swc_resultentryenabled_key);
         case GateStart:
             return key(R.string.preference_racing_procedure_gatestart_resultentryenabled_key);
         case ESS:
@@ -289,6 +295,15 @@ public class AppPreferences {
         return flags;
     }
 
+    public Set<Flags> getSWCStartmodeFlags() {
+        Set<String> flagNames = helper.getStringSet(key(R.string.preference_racing_procedure_swc_startmode_flags_key), new HashSet<String>());
+        Set<Flags> flags = new HashSet<>();
+        for (String flagName : flagNames) {
+            flags.add(Flags.valueOf(flagName));
+        }
+        return flags;
+    }
+
     public String getServerBaseURL() {
         return helper.getString(key(R.string.preference_server_url_key), null);
     }
@@ -423,6 +438,14 @@ public class AppPreferences {
         helper.getEditor().putStringSet(key(R.string.preference_racing_procedure_rrs26_startmode_flags_key), flagNames).commit();
     }
 
+    public void setSWCStartmodeFlags(Set<Flags> flags) {
+        Set<String> flagNames = new HashSet<>();
+        for (Flags flag : flags) {
+            flagNames.add(flag.name());
+        }
+        helper.getEditor().putStringSet(key(R.string.preference_racing_procedure_swc_startmode_flags_key), flagNames).commit();
+    }
+
     public void setSendingActive(boolean activate) {
         ExLog.i(context, this.getClass().toString(), "setSendingActive: " + activate);
         helper.getEditor().putBoolean(context.getResources().getString(R.string.preference_isSendingActive_key), activate).commit();

mobile/com.sap.sailing.racecommittee.app/src/com/sap/sailing/racecommittee/app/domain/configuration/impl/PreferencesRegattaConfigurationLoader.java

@@ -13,11 +13,12 @@ import com.sap.sailing.domain.base.configuration.impl.LeagueConfigurationImpl;
 import com.sap.sailing.domain.base.configuration.impl.RRS26ConfigurationImpl;
 import com.sap.sailing.domain.base.configuration.impl.RacingProcedureConfigurationImpl;
 import com.sap.sailing.domain.base.configuration.impl.RegattaConfigurationImpl;
+import com.sap.sailing.domain.base.configuration.impl.SWCConfigurationImpl;
 import com.sap.sailing.domain.base.configuration.procedures.ESSConfiguration;
 import com.sap.sailing.domain.base.configuration.procedures.GateStartConfiguration;
 import com.sap.sailing.domain.base.configuration.procedures.LeagueConfiguration;
 import com.sap.sailing.domain.base.configuration.procedures.RRS26Configuration;
-import com.sap.sailing.domain.common.racelog.Flags;
+import com.sap.sailing.domain.base.configuration.procedures.SWCConfiguration;
 import com.sap.sailing.domain.common.racelog.RacingProcedureType;
 import com.sap.sailing.racecommittee.app.AppPreferences;
 
@@ -52,9 +53,16 @@ public class PreferencesRegattaConfigurationLoader implements ConfigurationLoade
         rrs26.setClassFlag(preferences.getRacingProcedureClassFlag(RacingProcedureType.RRS26));
         rrs26.setHasIndividualRecall(preferences.getRacingProcedureHasIndividualRecall(RacingProcedureType.RRS26));
         rrs26.setResultEntryEnabled(preferences.getRacingProcedureIsResultEntryEnabled(RacingProcedureType.RRS26));
-        rrs26.setStartModeFlags(new ArrayList<Flags>(preferences.getRRS26StartmodeFlags()));
+        rrs26.setStartModeFlags(new ArrayList<>(preferences.getRRS26StartmodeFlags()));
         configuration.setRRS26Configuration(rrs26);
 
+        SWCConfigurationImpl swcStart = new SWCConfigurationImpl();
+        swcStart.setClassFlag(preferences.getRacingProcedureClassFlag(RacingProcedureType.SWC));
+        swcStart.setHasIndividualRecall(preferences.getRacingProcedureHasIndividualRecall(RacingProcedureType.SWC));
+        swcStart.setResultEntryEnabled(preferences.getRacingProcedureIsResultEntryEnabled(RacingProcedureType.SWC));
+        swcStart.setStartModeFlags(new ArrayList<>(preferences.getSWCStartmodeFlags()));
+        configuration.setSWCConfiguration(swcStart);
+
         GateStartConfigurationImpl gateStart = new GateStartConfigurationImpl();
         gateStart.setClassFlag(preferences.getRacingProcedureClassFlag(RacingProcedureType.GateStart));
         gateStart.setHasIndividualRecall(preferences.getRacingProcedureHasIndividualRecall(RacingProcedureType.GateStart));
@@ -100,9 +108,17 @@ public class PreferencesRegattaConfigurationLoader implements ConfigurationLoade
             RRS26Configuration config = configuration.getRRS26Configuration();
             storeRacingProcedureConfiguration(RacingProcedureType.RRS26, config);
             if (config.getStartModeFlags() != null) {
-                preferences.setRRS26StartmodeFlags(new HashSet<Flags>(config.getStartModeFlags()));
+                preferences.setRRS26StartmodeFlags(new HashSet<>(config.getStartModeFlags()));
             }
         }
+        if (configuration.getSWCConfiguration() != null) {
+            SWCConfiguration config = configuration.getSWCConfiguration();
+            storeRacingProcedureConfiguration(RacingProcedureType.SWC, config);
+            if (config.getStartModeFlags() != null) {
+                preferences.setSWCStartmodeFlags(new HashSet<>(config.getStartModeFlags()));
+            }
+        }
+
         if (configuration.getGateStartConfiguration() != null) {
             GateStartConfiguration config = configuration.getGateStartConfiguration();
             storeRacingProcedureConfiguration(RacingProcedureType.GateStart, config);

mobile/com.sap.sailing.racecommittee.app/src/com/sap/sailing/racecommittee/app/ui/fragments/panels/FinishedButtonFragment.java

@@ -18,10 +18,7 @@ import com.sap.sailing.android.shared.logging.ExLog;
 import com.sap.sailing.android.shared.util.ViewHelper;
 import com.sap.sailing.racecommittee.app.AppConstants;
 import com.sap.sailing.racecommittee.app.R;
-import com.sap.sailing.racecommittee.app.ui.fragments.raceinfo.CourseFragment;
-import com.sap.sailing.racecommittee.app.ui.fragments.raceinfo.LineStartModeFragment;
 import com.sap.sailing.racecommittee.app.ui.fragments.raceinfo.PhotoListFragment;
-import com.sap.sailing.racecommittee.app.ui.fragments.raceinfo.StartProcedureFragment;
 import com.sap.sailing.racecommittee.app.ui.fragments.raceinfo.TrackingListFragment;
 
 public class FinishedButtonFragment extends BasePanelFragment {
@@ -110,17 +107,17 @@ public class FinishedButtonFragment extends BasePanelFragment {
     private void uncheckMarker(View view) {
         if (isAdded() && view != null) {
             if (!view.equals(mRecord)) {
-                resetFragment(null, getFrameId(getActivity(), R.id.race_edit, R.id.race_content, false), StartProcedureFragment.class);
+                // TODO
                 setMarkerLevel(mRecord, R.id.record_marker, LEVEL_NORMAL);
             }
 
             if (!view.equals(mPhoto)) {
-                resetFragment(null, getFrameId(getActivity(), R.id.race_edit, R.id.race_content, false), LineStartModeFragment.class);
+                resetFragment(null, getFrameId(getActivity(), R.id.race_edit, R.id.race_content, false), PhotoListFragment.class);
                 setMarkerLevel(mPhoto, R.id.photo_marker, LEVEL_NORMAL);
             }
 
             if (!view.equals(mList)) {
-                resetFragment(null, getFrameId(getActivity(), R.id.race_edit, R.id.race_content, false), CourseFragment.class);
+                resetFragment(null, getFrameId(getActivity(), R.id.race_edit, R.id.race_content, false), TrackingListFragment.class);
                 setMarkerLevel(mList, R.id.list_marker, LEVEL_NORMAL);
             }
         }

mobile/com.sap.sailing.racecommittee.app/src/com/sap/sailing/racecommittee/app/ui/fragments/panels/MorePanelFragment.java

@@ -1,436 +0,0 @@
-package com.sap.sailing.racecommittee.app.ui.fragments.panels;
-
-import android.content.BroadcastReceiver;
-import android.content.Context;
-import android.content.DialogInterface;
-import android.content.Intent;
-import android.content.IntentFilter;
-import android.os.Bundle;
-import android.support.v4.content.LocalBroadcastManager;
-import android.view.LayoutInflater;
-import android.view.View;
-import android.view.ViewGroup;
-import android.widget.ImageView;
-import android.widget.TextView;
-
-import com.sap.sailing.android.shared.logging.ExLog;
-import com.sap.sailing.android.shared.util.AppUtils;
-import com.sap.sailing.android.shared.util.ViewHelper;
-import com.sap.sailing.domain.abstractlog.race.state.ReadonlyRaceState;
-import com.sap.sailing.domain.abstractlog.race.state.impl.BaseRaceStateChangedListener;
-import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.RacingProcedure;
-import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.ReadonlyRacingProcedure;
-import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.gate.GateStartRacingProcedure;
-import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.impl.BaseRacingProcedureChangedListener;
-import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.rrs26.RRS26RacingProcedure;
-import com.sap.sailing.racecommittee.app.AppConstants;
-import com.sap.sailing.racecommittee.app.R;
-import com.sap.sailing.racecommittee.app.ui.fragments.raceinfo.GateStartPathFinderFragment;
-import com.sap.sailing.racecommittee.app.ui.fragments.raceinfo.GateStartTimingFragment;
-import com.sap.sailing.racecommittee.app.ui.fragments.raceinfo.LineStartModeFragment;
-import com.sap.sailing.racecommittee.app.ui.utils.FlagsResources;
-import com.sap.sailing.racecommittee.app.utils.RaceHelper;
-
-public class MorePanelFragment extends BasePanelFragment {
-
-    private RaceStateChangedListener mStateListener;
-    private RaceProcedureChangedListener mProcedureListener;
-    private IntentReceiver mReceiver;
-
-    // Start Mode Toggle
-    private View mStartMode;
-    private View mStartModeLock;
-    private ImageView mStartModeFlag;
-    private View mStartModeLayer;
-
-    // Gate Start PathFinder
-    private View mGatePathfinder;
-    private View mGatePathfinderLock;
-    private TextView mGatePathfinderValue;
-    private View mGatePathfinderLayer;
-
-    // Gate Start Timing
-    private View mGateTiming;
-    private View mGateTimingLock;
-    private TextView mGateTimingValue;
-    private View mGateTimingLayer;
-
-    public MorePanelFragment() {
-        mReceiver = new IntentReceiver();
-    }
-
-    public static MorePanelFragment newInstance(Bundle args) {
-        MorePanelFragment fragment = new MorePanelFragment();
-        fragment.setArguments(args);
-        return fragment;
-    }
-
-    @Override
-    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
-        View layout = inflater.inflate(R.layout.race_panel_more, container, false);
-
-        mStateListener = new RaceStateChangedListener();
-        mProcedureListener = new RaceProcedureChangedListener();
-
-        mStartMode = ViewHelper.get(layout, R.id.start_mode);
-        if (mStartMode != null) {
-            mStartMode.setOnClickListener(new StartModeClick());
-        }
-        mStartModeLock = ViewHelper.get(layout, R.id.start_mode_lock);
-        mStartModeFlag = ViewHelper.get(layout, R.id.start_mode_flag);
-        mStartModeLayer = ViewHelper.get(layout, R.id.start_mode_layer);
-
-        mGatePathfinder = ViewHelper.get(layout, R.id.gate_pathfinder);
-        if (mGatePathfinder != null) {
-            mGatePathfinder.setOnClickListener(new PathfinderClick());
-        }
-        mGatePathfinderLock = ViewHelper.get(layout, R.id.gate_pathfinder_lock);
-        mGatePathfinderValue = ViewHelper.get(layout, R.id.gate_pathfinder_value);
-        mGatePathfinderLayer = ViewHelper.get(layout, R.id.gate_pathfinder_layer);
-
-        mGateTiming = ViewHelper.get(layout, R.id.gate_timing);
-        if (mGateTiming != null) {
-            mGateTiming.setOnClickListener(new TimingClick());
-        }
-        mGateTimingLock = ViewHelper.get(layout, R.id.gate_timing_lock);
-        mGateTimingValue = ViewHelper.get(layout, R.id.gate_timing_value);
-        mGateTimingLayer = ViewHelper.get(layout, R.id.gate_timing_layer);
-
-        View view = ViewHelper.get(layout, R.id.top_line);
-        if (view != null && AppUtils.with(getActivity()).isPort()) {
-            view.setVisibility(View.GONE);
-        }
-
-        return layout;
-    }
-
-    @Override
-    public void onResume() {
-        super.onResume();
-
-        refreshPanel();
-        checkStatus();
-
-        getRaceState().addChangedListener(mStateListener);
-        getRaceState().getRacingProcedure().addChangedListener(mProcedureListener);
-
-        IntentFilter filter = new IntentFilter();
-        filter.addAction(AppConstants.INTENT_ACTION_TOGGLE);
-        filter.addAction(AppConstants.INTENT_ACTION_CLEAR_TOGGLE);
-        LocalBroadcastManager.getInstance(getActivity()).registerReceiver(mReceiver, filter);
-    }
-
-    @Override
-    public void onPause() {
-        super.onPause();
-
-        getRaceState().removeChangedListener(mStateListener);
-        getRaceState().getRacingProcedure().removeChangedListener(mProcedureListener);
-
-        LocalBroadcastManager.getInstance(getActivity()).unregisterReceiver(mReceiver);
-    }
-
-    private void refreshPanel() {
-        RacingProcedure procedure = getRaceState().getRacingProcedure();
-        if (procedure instanceof RRS26RacingProcedure) {
-            RRS26RacingProcedure typedProcedure = getRaceState().getTypedRacingProcedure();
-            if (mStartMode != null && mStartModeFlag != null) {
-                mStartMode.setVisibility(View.VISIBLE);
-                mStartModeFlag.setImageDrawable(FlagsResources
-                        .getFlagDrawable(getActivity(), typedProcedure.getStartModeFlag().name(), getResources().getInteger(R.integer.flag_size)));
-            }
-        }
-
-        if (procedure instanceof GateStartRacingProcedure) {
-            GateStartRacingProcedure typedProcedure = getRaceState().getTypedRacingProcedure();
-            if (mGatePathfinder != null && mGatePathfinderValue != null) {
-                mGatePathfinder.setVisibility(View.VISIBLE);
-                mGatePathfinderValue.setText(typedProcedure.getPathfinder());
-            }
-
-            if (mGateTiming != null && mGateTimingValue != null) {
-                mGateTiming.setVisibility(View.VISIBLE);
-                mGateTimingValue.setText(RaceHelper.getGateTiming(getActivity(), typedProcedure, getRace().getRaceGroup()));
-            }
-        }
-    }
-
-    private void checkStatus() {
-        switch (getRace().getStatus()) {
-            case UNSCHEDULED:
-                changeVisibility(mStartModeLock, mStartModeLayer, View.GONE);
-                changeVisibility(mGatePathfinderLock, mGatePathfinderLayer, View.GONE);
-                changeVisibility(mGateTimingLock, mGateTimingLayer, View.GONE);
-                break;
-
-            case PRESCHEDULED:
-                changeVisibility(mStartModeLock, mStartModeLayer, View.GONE);
-                changeVisibility(mGatePathfinderLock, mGatePathfinderLayer, View.GONE);
-                changeVisibility(mGateTimingLock, mGateTimingLayer, View.GONE);
-                break;
-
-            case SCHEDULED:
-                changeVisibility(mStartModeLock, mStartModeLayer, View.GONE);
-                changeVisibility(mGatePathfinderLock, mGatePathfinderLayer, View.GONE);
-                changeVisibility(mGateTimingLock, mGateTimingLayer, View.GONE);
-                break;
-
-            case STARTPHASE:
-                changeVisibility(mStartModeLock, mStartModeLayer, View.VISIBLE);
-                changeVisibility(mGatePathfinderLock, mGatePathfinderLayer, View.VISIBLE);
-                changeVisibility(mGateTimingLock, mGateTimingLayer, View.VISIBLE);
-                break;
-
-            case RUNNING:
-                changeVisibility(mStartModeLock, mStartModeLayer, View.VISIBLE);
-                changeVisibility(mGatePathfinderLock, mGatePathfinderLayer, View.VISIBLE);
-                changeVisibility(mGateTimingLock, mGateTimingLayer, View.VISIBLE);
-
-                uncheckMarker(mStartMode);
-                break;
-
-            case FINISHING:
-                changeVisibility(mStartModeLock, mStartModeLayer, View.VISIBLE);
-                changeVisibility(mGatePathfinderLock, mGatePathfinderLayer, View.VISIBLE);
-                changeVisibility(mGateTimingLock, mGateTimingLayer, View.VISIBLE);
-
-                uncheckMarker(mStartMode);
-                break;
-
-            case FINISHED:
-                changeVisibility(mStartModeLock, mStartModeLayer, View.GONE);
-                changeVisibility(mGatePathfinderLock, mGatePathfinderLayer, View.GONE);
-                changeVisibility(mGateTimingLock, mGateTimingLayer, View.GONE);
-
-                uncheckMarker(mStartMode);
-                break;
-
-            default:
-                changeVisibility(mStartModeLock, mStartModeLayer, View.VISIBLE);
-                changeVisibility(mGatePathfinderLock, mGatePathfinderLayer, View.VISIBLE);
-                changeVisibility(mGateTimingLock, mGateTimingLayer, View.VISIBLE);
-
-                uncheckMarker(mStartMode);
-                break;
-        }
-    }
-
-    private void uncheckMarker(View view) {
-        if (isAdded() && view != null) {
-            if (!AppUtils.with(getActivity()).is10inch()) {
-                if (!view.equals(mStartMode)) {
-                    setMarkerLevel(mStartMode, R.id.start_mode_marker, LEVEL_NORMAL);
-                }
-                if (!view.equals(mGatePathfinder)) {
-                    setMarkerLevel(mGatePathfinder, R.id.gate_pathfinder_marker, LEVEL_NORMAL);
-                }
-                if (!view.equals(mGateTiming)) {
-                    setMarkerLevel(mGateTiming, R.id.gate_timing_marker, LEVEL_NORMAL);
-                }
-            }
-        }
-    }
-
-    private class RaceStateChangedListener extends BaseRaceStateChangedListener {
-
-        private View mView;
-
-        public RaceStateChangedListener() {
-            mView = new View(getActivity());
-        }
-
-        @Override
-        public void onRacingProcedureChanged(ReadonlyRaceState state) {
-            super.onRacingProcedureChanged(state);
-
-            refreshPanel();
-            uncheckMarker(mView);
-        }
-
-        @Override
-        public void onCourseDesignChanged(ReadonlyRaceState state) {
-            super.onCourseDesignChanged(state);
-
-            refreshPanel();
-            uncheckMarker(mView);
-        }
-
-        @Override
-        public void onWindFixChanged(ReadonlyRaceState state) {
-            super.onWindFixChanged(state);
-
-            refreshPanel();
-            uncheckMarker(mView);
-        }
-
-        @Override
-        public void onStatusChanged(ReadonlyRaceState state) {
-            super.onStatusChanged(state);
-
-            checkStatus();
-            uncheckMarker(mView);
-        }
-    }
-
-    private class RaceProcedureChangedListener extends BaseRacingProcedureChangedListener {
-
-        private View mView;
-
-        public RaceProcedureChangedListener() {
-            mView = new View(getActivity());
-        }
-
-        @Override
-        public void onActiveFlagsChanged(ReadonlyRacingProcedure racingProcedure) {
-            super.onActiveFlagsChanged(racingProcedure);
-
-            refreshPanel();
-            uncheckMarker(mView);
-        }
-    }
-
-    private class StartModeClick implements View.OnClickListener, DialogInterface.OnClickListener {
-
-        private final String TAG = StartModeClick.class.getName();
-        private final View container = mStartMode;
-        private final int markerId = R.id.start_mode_marker;
-
-        public void onClick(View v) {
-            if (mStartModeLock != null) {
-                if (mStartModeLock.getVisibility() == View.VISIBLE && isNormal(container, markerId)) {
-                    showChangeDialog(this);
-                } else {
-                    toggleFragment();
-                }
-            }
-        }
-
-        @Override
-        public void onClick(DialogInterface dialog, int which) {
-            toggleFragment();
-        }
-
-        private void toggleFragment() {
-            sendIntent(AppConstants.INTENT_ACTION_TOGGLE, AppConstants.INTENT_ACTION_EXTRA, AppConstants.INTENT_ACTION_TOGGLE_PROCEDURE_MORE_MODE);
-            switch (toggleMarker(container, markerId)) {
-                case LEVEL_NORMAL:
-                    sendIntent(AppConstants.INTENT_ACTION_SHOW_MAIN_CONTENT);
-                    break;
-
-                case LEVEL_TOGGLED:
-                    replaceFragment(LineStartModeFragment.newInstance(LineStartModeFragment.START_MODE_PLANNED));
-                    break;
-
-                default:
-                    ExLog.i(getActivity(), TAG, "Unknown return value");
-            }
-            disableToggle(container, markerId);
-        }
-    }
-
-    private class PathfinderClick implements View.OnClickListener, DialogInterface.OnClickListener {
-
-        private final String TAG = PathfinderClick.class.getName();
-        private final View container = mGatePathfinder;
-        private final int markerId = R.id.gate_pathfinder_marker;
-
-        @Override
-        public void onClick(View v) {
-            if (mGatePathfinderLock != null) {
-                if (mGatePathfinderLock.getVisibility() == View.VISIBLE && isNormal(container, markerId)) {
-                    showChangeDialog(this);
-                } else {
-                    toggleFragment();
-                }
-            }
-        }
-
-        @Override
-        public void onClick(DialogInterface dialog, int which) {
-            toggleFragment();
-        }
-
-        private void toggleFragment() {
-            sendIntent(AppConstants.INTENT_ACTION_TOGGLE, AppConstants.INTENT_ACTION_EXTRA, AppConstants.INTENT_ACTION_TOGGLE_PROCEDURE_MORE_PATHFINDER);
-            switch (toggleMarker(container, markerId)) {
-                case LEVEL_NORMAL:
-                    sendIntent(AppConstants.INTENT_ACTION_SHOW_MAIN_CONTENT);
-                    break;
-
-                case LEVEL_TOGGLED:
-                    replaceFragment(GateStartPathFinderFragment.newInstance(GateStartPathFinderFragment.START_MODE_PLANNED));
-                    break;
-
-                default:
-                    ExLog.i(getActivity(), TAG, "Unknown return value");
-            }
-            disableToggle(container, markerId);
-        }
-    }
-
-    private class TimingClick implements View.OnClickListener, DialogInterface.OnClickListener {
-
-        private final String TAG = TimingClick.class.getName();
-        private final View container = mGateTiming;
-        private final int markerId = R.id.gate_timing_marker;
-
-        @Override
-        public void onClick(View v) {
-            if (mGateTimingLock != null) {
-                if (mGateTimingLock.getVisibility() == View.VISIBLE && isNormal(container, markerId)) {
-                    showChangeDialog(this);
-                } else {
-                    toggleFragment();
-                }
-            }
-        }
-
-        @Override
-        public void onClick(DialogInterface dialog, int which) {
-            toggleFragment();
-        }
-
-        private void toggleFragment() {
-            sendIntent(AppConstants.INTENT_ACTION_TOGGLE, AppConstants.INTENT_ACTION_EXTRA, AppConstants.INTENT_ACTION_TOGGLE_PROCEDURE_MORE_TIMING);
-            switch (toggleMarker(container, markerId)) {
-                case LEVEL_NORMAL:
-                    sendIntent(AppConstants.INTENT_ACTION_SHOW_MAIN_CONTENT);
-                    break;
-
-                case LEVEL_TOGGLED:
-                    replaceFragment(GateStartTimingFragment.newInstance(GateStartTimingFragment.START_MODE_PLANNED));
-                    break;
-
-                default:
-                    ExLog.i(getActivity(), TAG, "Unknown return value");
-            }
-            disableToggle(container, markerId);
-        }
-    }
-
-    private class IntentReceiver extends BroadcastReceiver {
-
-        @Override
-        public void onReceive(Context context, Intent intent) {
-            String action = intent.getAction();
-            if (AppConstants.INTENT_ACTION_CLEAR_TOGGLE.equals(action)) {
-                uncheckMarker(new View(context));
-            }
-
-            if (AppConstants.INTENT_ACTION_TOGGLE.equals(action)) {
-                if (intent.getExtras() != null) {
-                    String data = intent.getExtras().getString(AppConstants.INTENT_ACTION_EXTRA);
-                    if (AppConstants.INTENT_ACTION_TOGGLE_PROCEDURE_MORE_MODE.equals(data)) {
-                        uncheckMarker(mStartMode);
-                    } else if (AppConstants.INTENT_ACTION_TOGGLE_PROCEDURE_MORE_PATHFINDER.equals(data)) {
-                        uncheckMarker(mGatePathfinder);
-                    } else if (AppConstants.INTENT_ACTION_TOGGLE_PROCEDURE_MORE_TIMING.equals(data)) {
-                        uncheckMarker(mGateTiming);
-                    } else {
-                        uncheckMarker(new View(context));
-                    }
-                }
-            }
-        }
-    }
-}

mobile/com.sap.sailing.racecommittee.app/src/com/sap/sailing/racecommittee/app/ui/fragments/panels/SetupPanelFragment.java

@@ -21,7 +21,7 @@ import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.ReadonlyRac
 import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.ess.ESSRacingProcedure;
 import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.gate.GateStartRacingProcedure;
 import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.impl.BaseRacingProcedureChangedListener;
-import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.rrs26.RRS26RacingProcedure;
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.line.ConfigurableStartModeFlagRacingProcedure;
 import com.sap.sailing.domain.common.Wind;
 import com.sap.sailing.racecommittee.app.AppConstants;
 import com.sap.sailing.racecommittee.app.R;
@@ -29,8 +29,8 @@ import com.sap.sailing.racecommittee.app.ui.fragments.raceinfo.BaseFragment;
 import com.sap.sailing.racecommittee.app.ui.fragments.raceinfo.CourseFragment;
 import com.sap.sailing.racecommittee.app.ui.fragments.raceinfo.GateStartPathFinderFragment;
 import com.sap.sailing.racecommittee.app.ui.fragments.raceinfo.GateStartTimingFragment;
-import com.sap.sailing.racecommittee.app.ui.fragments.raceinfo.LineStartModeFragment;
 import com.sap.sailing.racecommittee.app.ui.fragments.raceinfo.RaceFactorFragment;
+import com.sap.sailing.racecommittee.app.ui.fragments.raceinfo.StartModeFragment;
 import com.sap.sailing.racecommittee.app.ui.fragments.raceinfo.StartProcedureFragment;
 import com.sap.sailing.racecommittee.app.ui.fragments.raceinfo.WindFragment;
 import com.sap.sailing.racecommittee.app.ui.utils.FlagsResources;
@@ -176,9 +176,9 @@ public class SetupPanelFragment extends BasePanelFragment {
                 mButtonRaceGroup.setVisibility(View.GONE);
             }
 
-            if (getRaceState().getRacingProcedure() instanceof RRS26RacingProcedure) {
+            if (getRaceState().getRacingProcedure() instanceof ConfigurableStartModeFlagRacingProcedure) {
                 if (mButtonMode != null) {
-                    RRS26RacingProcedure typedProcedure = getRaceState().getTypedRacingProcedure();
+                    ConfigurableStartModeFlagRacingProcedure typedProcedure = getRaceState().getTypedRacingProcedure();
                     mButtonMode.setPanelImage(FlagsResources.getFlagDrawable(getActivity(), typedProcedure.getStartModeFlag().name(), getResources().getInteger(R.integer.flag_size)));
                     mButtonMode.setVisibility(View.VISIBLE);
                 }
@@ -344,7 +344,7 @@ public class SetupPanelFragment extends BasePanelFragment {
                 mButtonProcedure.setMarkerLevel(PanelButton.LEVEL_NORMAL);
             }
             if (mButtonMode != null && !mButtonMode.equals(view)) {
-                resetFragment(mButtonMode.isLocked(), getFrameId(getActivity(), R.id.race_edit, R.id.race_content, false), LineStartModeFragment.class);
+                resetFragment(mButtonMode.isLocked(), getFrameId(getActivity(), R.id.race_edit, R.id.race_content, false), StartModeFragment.class);
                 mButtonMode.setMarkerLevel(PanelButton.LEVEL_NORMAL);
             }
             if (mButtonPathfinder != null && !mButtonPathfinder.equals(view)) {
@@ -466,7 +466,7 @@ public class SetupPanelFragment extends BasePanelFragment {
                     break;
 
                 case PanelButton.LEVEL_TOGGLED:
-                    replaceFragment(LineStartModeFragment.newInstance(LineStartModeFragment.START_MODE_PLANNED));
+                    replaceFragment(StartModeFragment.newInstance(StartModeFragment.START_MODE_PLANNED));
                     break;
 
                 default:

mobile/com.sap.sailing.racecommittee.app/src/com/sap/sailing/racecommittee/app/ui/fragments/preference/RegattaPreferenceFragment.java

@@ -8,6 +8,7 @@ import java.util.Set;
 import android.os.Bundle;
 import android.preference.ListPreference;
 import android.preference.MultiSelectListPreference;
+import android.support.annotation.StringRes;
 import android.text.TextUtils;
 
 import com.sap.sailing.android.shared.ui.fragments.preference.BasePreferenceFragment;
@@ -39,6 +40,8 @@ public class RegattaPreferenceFragment extends BasePreferenceFragment {
 
         bindPreferenceSummaryToValue(findPreference(R.string.preference_racing_procedure_rrs26_classflag_key));
         bindPreferenceSummaryToSet(findPreference(R.string.preference_racing_procedure_rrs26_startmode_flags_key));
+        bindPreferenceSummaryToValue(findPreference(R.string.preference_racing_procedure_swc_classflag_key));
+        bindPreferenceSummaryToSet(findPreference(R.string.preference_racing_procedure_swc_startmode_flags_key));
         bindPreferenceSummaryToValue(findPreference(R.string.preference_racing_procedure_gatestart_classflag_key));
         bindPreferenceSummaryToValue(findPreference(R.string.preference_racing_procedure_ess_classflag_key));
         bindPreferenceSummaryToValue(findPreference(R.string.preference_racing_procedure_basic_classflag_key));
@@ -46,6 +49,7 @@ public class RegattaPreferenceFragment extends BasePreferenceFragment {
 
         setupGeneral();
         setupRRS26();
+        setupSWC();
         setupGateStart();
         setupESS();
         setupBasic();
@@ -53,10 +57,15 @@ public class RegattaPreferenceFragment extends BasePreferenceFragment {
     }
 
     private void setupRRS26() {
-        setupRRS26StartmodeFlagsList();
+        setupStartmodeFlagsList(R.string.preference_racing_procedure_rrs26_startmode_flags_key);
         setupClassFlagList(this.<ListPreference>findPreference(R.string.preference_racing_procedure_rrs26_classflag_key));
     }
 
+    private void setupSWC() {
+        setupStartmodeFlagsList(R.string.preference_racing_procedure_swc_startmode_flags_key);
+        setupClassFlagList(this.<ListPreference>findPreference(R.string.preference_racing_procedure_swc_classflag_key));
+    }
+
     private void setupGateStart() {
         setupClassFlagList(this.<ListPreference>findPreference(R.string.preference_racing_procedure_gatestart_classflag_key));
     }
@@ -122,8 +131,8 @@ public class RegattaPreferenceFragment extends BasePreferenceFragment {
         bindPreferenceSummaryToInteger(findPreference(R.string.preference_protest_time_duration_key));
     }
 
-    private void setupRRS26StartmodeFlagsList() {
-        MultiSelectListPreference preference = findPreference(R.string.preference_racing_procedure_rrs26_startmode_flags_key);
+    private void setupStartmodeFlagsList(@StringRes int prefId) {
+        MultiSelectListPreference preference = findPreference(prefId);
         List<String> flags = new ArrayList<>();
         for (Flags flag : Flags.validValues()) {
             flags.add(flag.name());

mobile/com.sap.sailing.racecommittee.app/src/com/sap/sailing/racecommittee/app/ui/fragments/raceinfo/MainScheduleFragment.java

@@ -19,12 +19,12 @@ import com.sap.sailing.domain.abstractlog.race.SimpleRaceLogIdentifier;
 import com.sap.sailing.domain.abstractlog.race.scoring.AdditionalScoringInformationType;
 import com.sap.sailing.domain.abstractlog.race.state.ReadonlyRaceState;
 import com.sap.sailing.domain.abstractlog.race.state.impl.BaseRaceStateChangedListener;
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.RacingProcedure;
 import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.ess.ESSRacingProcedure;
 import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.gate.GateStartRacingProcedure;
-import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.rrs26.RRS26RacingProcedure;
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.line.ConfigurableStartModeFlagRacingProcedure;
 import com.sap.sailing.domain.common.Wind;
 import com.sap.sailing.domain.common.racelog.Flags;
-import com.sap.sailing.domain.common.racelog.RacingProcedureType;
 import com.sap.sailing.racecommittee.app.R;
 import com.sap.sailing.racecommittee.app.data.DataManager;
 import com.sap.sailing.racecommittee.app.domain.ManagedRace;
@@ -59,7 +59,7 @@ public class MainScheduleFragment extends BaseFragment implements View.OnClickLi
     private SimpleRaceLogIdentifier mRaceId;
     private TimePoint mStartTime;
     private Duration mStartTimeDiff;
-    private RacingProcedureType mRacingProcedureType;
+    private RacingProcedure mRacingProcedure;
     private TimePoint lastTick;
 
     private Calendar mCalendar;
@@ -146,29 +146,27 @@ public class MainScheduleFragment extends BaseFragment implements View.OnClickLi
     }
 
     private void initStartMode() {
-        mRacingProcedureType = getRaceState().getRacingProcedure().getType();
-        if (mRacingProcedureType != null) {
+        mRacingProcedure = getRaceState().getRacingProcedure();
+        if (mRacingProcedure != null) {
             Runnable runnableProcedure = new Runnable() {
                 @Override
                 public void run() {
                     openFragment(StartProcedureFragment.newInstance(START_MODE_PRESETUP));
                 }
             };
-            mItems.add(new SelectionItem(getString(R.string.start_procedure), mRacingProcedureType.toString(), null, false, false, runnableProcedure));
-            if (RacingProcedureType.RRS26.equals(mRacingProcedureType)) {
-                // LineStart
-                RRS26RacingProcedure procedure = getRaceState().getTypedRacingProcedure();
+            mItems.add(new SelectionItem(getString(R.string.start_procedure), mRacingProcedure.getType().toString(), null, false, false, runnableProcedure));
+            if (mRacingProcedure instanceof ConfigurableStartModeFlagRacingProcedure) {
+                final ConfigurableStartModeFlagRacingProcedure procedure = getRaceState().getTypedRacingProcedure();
                 Flags flag = procedure.getStartModeFlag();
                 Runnable runnableMode = new Runnable() {
                     @Override
                     public void run() {
-                        openFragment(LineStartModeFragment.newInstance(START_MODE_PRESETUP));
+                        openFragment(StartModeFragment.newInstance(START_MODE_PRESETUP));
                     }
                 };
                 Drawable drawable = FlagsResources.getFlagDrawable(getActivity(), flag.name(), mFlagSize);
                 mItems.add(new SelectionItem(getString(R.string.start_mode), flag.name(), drawable, false, false, runnableMode));
-            } else if (RacingProcedureType.GateStart.equals(mRacingProcedureType)) {
-                // GateStart
+            } else if (mRacingProcedure instanceof GateStartRacingProcedure) {
                 GateStartRacingProcedure procedure = getRaceState().getTypedRacingProcedure();
                 if (procedure != null) {
                     Runnable runnablePathfinder = new Runnable() {
@@ -187,8 +185,7 @@ public class MainScheduleFragment extends BaseFragment implements View.OnClickLi
                     };
                     mItems.add(new SelectionItem(getString(R.string.gate_start_timing), RaceHelper.getGateTiming(getActivity(), procedure, getRace().getRaceGroup()), null, false, false, runnableTiming));
                 }
-            } else if (RacingProcedureType.ESS.equals(mRacingProcedureType)) {
-                // Extreme Sailing Series
+            } else if (mRacingProcedure instanceof ESSRacingProcedure) {
                 ESSRacingProcedure procedure = getRaceState().getTypedRacingProcedure();
                 if (procedure != null) {
                     boolean checked = getArguments().getBoolean(RACE_GROUP, getRaceState().isAdditionalScoringInformationEnabled(AdditionalScoringInformationType.MAX_POINTS_DECREASE_MAX_SCORE));
@@ -253,16 +250,16 @@ public class MainScheduleFragment extends BaseFragment implements View.OnClickLi
     }
 
     private void startRace() {
-        RRS26RacingProcedure rrs26Procedure = null;
+        ConfigurableStartModeFlagRacingProcedure lineStartRacingProcedure = null;
 
         Flags flag = null;
-        if (RacingProcedureType.RRS26.equals(getRaceState().getRacingProcedure().getType())) {
-            rrs26Procedure = getRaceState().getTypedRacingProcedure();
-            flag = rrs26Procedure.getStartModeFlag();
+        if (getRaceState().getRacingProcedure() instanceof ConfigurableStartModeFlagRacingProcedure) {
+            lineStartRacingProcedure = getRaceState().getTypedRacingProcedure();
+            flag = lineStartRacingProcedure.getStartModeFlag();
         }
         TimePoint now = MillisecondsTimePoint.now();
-        getRaceState().setRacingProcedure(now, mRacingProcedureType);
-        if (RacingProcedureType.ESS.equals(mRacingProcedureType) && mItemRaceGroup != null) {
+        getRaceState().setRacingProcedure(now, mRacingProcedure.getType());
+        if (mRacingProcedure instanceof ESSRacingProcedure && mItemRaceGroup != null) {
             getRaceState().setAdditionalScoringInformationEnabled(MillisecondsTimePoint.now(), /*enable*/ mItemRaceGroup.isChecked(),
                     AdditionalScoringInformationType.MAX_POINTS_DECREASE_MAX_SCORE);
         }
@@ -271,8 +268,8 @@ public class MainScheduleFragment extends BaseFragment implements View.OnClickLi
         } else {
             getRaceState().forceNewDependentStartTime(now, mStartTimeDiff, mRaceId);
         }
-        if (rrs26Procedure != null) {
-            rrs26Procedure.setStartModeFlag(MillisecondsTimePoint.now(), flag);
+        if (lineStartRacingProcedure != null) {
+            lineStartRacingProcedure.setStartModeFlag(MillisecondsTimePoint.now(), flag);
         }
     }
 

mobile/com.sap.sailing.racecommittee.app/src/com/sap/sailing/racecommittee/app/ui/fragments/raceinfo/RaceSummaryFragment.java

@@ -15,6 +15,7 @@ import com.sap.sailing.domain.abstractlog.race.state.ReadonlyRaceState;
 import com.sap.sailing.domain.common.Wind;
 import com.sap.sailing.racecommittee.app.R;
 import com.sap.sailing.racecommittee.app.utils.TimeUtils;
+import com.sap.sse.common.TimeRange;
 
 public class RaceSummaryFragment extends BaseFragment {
 
@@ -26,6 +27,10 @@ public class RaceSummaryFragment extends BaseFragment {
     private TextView mFinishEndTime;
     private TextView mFinishEndDuration;
     private TextView mFinishDuration;
+    private View mRegionProtest;
+    private TextView mProtestTimeStart;
+    private TextView mProtestTimeEnd;
+    private TextView mProtestTimeDuration;
     private View mRegionWind;
     private View mRegionRecall;
 
@@ -48,6 +53,10 @@ public class RaceSummaryFragment extends BaseFragment {
         mFinishEndTime = ViewHelper.get(layout, R.id.race_finish_end_time);
         mFinishEndDuration = ViewHelper.get(layout, R.id.race_finish_end_duration);
         mFinishDuration = ViewHelper.get(layout, R.id.race_finish_duration);
+        mRegionProtest = ViewHelper.get(layout, R.id.region_protest);
+        mProtestTimeStart = ViewHelper.get(layout, R.id.protest_time_start);
+        mProtestTimeEnd = ViewHelper.get(layout, R.id.protest_time_end);
+        mProtestTimeDuration = ViewHelper.get(layout, R.id.protest_time_duration);
         mRegionWind = ViewHelper.get(layout, R.id.region_wind);
         mRegionRecall = ViewHelper.get(layout, R.id.region_individual_recalls);
 
@@ -144,6 +153,24 @@ public class RaceSummaryFragment extends BaseFragment {
             mFinishDuration.setText(TimeUtils.formatTimeAgo(getActivity(), finishedTime.getTimeInMillis() - finishingTime.getTimeInMillis()));
         }
 
+        if (mRegionProtest != null) {
+            mRegionProtest.setVisibility(View.GONE);
+            if (getRaceState().getProtestTime() != null) {
+                mRegionProtest.setVisibility(View.VISIBLE);
+
+                TimeRange protestTime = getRaceState().getProtestTime();
+                if (mProtestTimeStart != null) {
+                    mProtestTimeStart.setText(mDateFormat.format(protestTime.from().asDate()));
+                }
+                if (mProtestTimeEnd != null) {
+                    mProtestTimeEnd.setText(mDateFormat.format(protestTime.to().asDate()));
+                }
+                if (mProtestTimeDuration != null) {
+                    mProtestTimeDuration.setText(TimeUtils.formatTimeAgo(getActivity(), protestTime.to().minus(protestTime.from().asMillis()).asMillis()));
+                }
+            }
+        }
+
         if (mRegionWind != null) {
             mRegionWind.setVisibility(View.GONE);
             if (getRaceState().getWindFix() != null) {

mobile/com.sap.sailing.racecommittee.app/src/com/sap/sailing/racecommittee/app/ui/fragments/raceinfo/StartModeFragment.java

@@ -14,7 +14,7 @@ import android.widget.AdapterView;
 import android.widget.ListView;
 
 import com.sap.sailing.android.shared.util.AppUtils;
-import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.rrs26.RRS26RacingProcedure;
+import com.sap.sailing.domain.abstractlog.race.state.racingprocedure.line.ConfigurableStartModeFlagRacingProcedure;
 import com.sap.sailing.domain.common.racelog.Flags;
 import com.sap.sailing.racecommittee.app.AppConstants;
 import com.sap.sailing.racecommittee.app.R;
@@ -24,14 +24,14 @@ import com.sap.sailing.racecommittee.app.ui.layouts.HeaderLayout;
 import com.sap.sailing.racecommittee.app.ui.utils.FlagsResources;
 import com.sap.sse.common.impl.MillisecondsTimePoint;
 
-public class LineStartModeFragment extends BaseFragment {
+public class StartModeFragment extends BaseFragment {
 
     private ListView mListView;
-    private RRS26RacingProcedure mProcedure;
+    private ConfigurableStartModeFlagRacingProcedure mLineStartProcedure;
     private int mFlagSize;
 
-    public static LineStartModeFragment newInstance(@START_MODE_VALUES int startMode) {
-        LineStartModeFragment fragment = new LineStartModeFragment();
+    public static StartModeFragment newInstance(@START_MODE_VALUES int startMode) {
+        StartModeFragment fragment = new StartModeFragment();
         Bundle args = new Bundle();
         args.putInt(START_MODE, startMode);
         fragment.setArguments(args);
@@ -58,7 +58,7 @@ public class LineStartModeFragment extends BaseFragment {
             }
         }
 
-        mProcedure = getRaceState().getTypedRacingProcedure();
+        mLineStartProcedure = getRaceState().getTypedRacingProcedure();
     }
 
     @Override
@@ -87,36 +87,39 @@ public class LineStartModeFragment extends BaseFragment {
         super.onResume();
 
         ArrayList<StartModeItem> startModes = new ArrayList<>();
-        List<Flags> flags = mProcedure.getConfiguration().getStartModeFlags();
-        int position = 0;
-        int selected = -1;
-        for (Flags flag : flags) {
-            StartModeItem startMode = new StartModeItem(flag);
-            startMode.setImage(FlagsResources.getFlagDrawable(getActivity(), startMode.getFlagName(), mFlagSize));
-            startModes.add(startMode);
-        }
-        Collections.sort(startModes, new StartModeComparator());
-        for (StartModeItem startModeItem : startModes) {
-            if (startModeItem.getFlag().equals(mProcedure.getStartModeFlag())) {
-                selected = position;
+        List<Flags> flags = mLineStartProcedure.getConfiguration().getStartModeFlags();
+        if (flags != null) {
+            int position = 0;
+            int selected = -1;
+            for (Flags flag : flags) {
+                StartModeItem startMode = new StartModeItem(flag);
+                startMode.setImage(FlagsResources.getFlagDrawable(getActivity(), startMode.getFlagName(), mFlagSize));
+                startModes.add(startMode);
             }
-            position++;
-        }
-        final CheckedItemAdapter adapter = new CheckedItemAdapter(getActivity(), startModes);
-        adapter.setCheckedPosition(selected);
-        mListView.setAdapter(adapter);
-        mListView.setOnItemClickListener(new AdapterView.OnItemClickListener() {
-            @Override
-            public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
-                adapter.setCheckedPosition(position);
-                StartModeItem item = (StartModeItem) adapter.getItem(position);
-                if (item != null) {
-                    onClick(item);
+            Collections.sort(startModes, new StartModeComparator());
+            for (StartModeItem startModeItem : startModes) {
+                Flags flag = mLineStartProcedure.getStartModeFlag();
+                if (startModeItem.getFlag().equals(flag)) {
+                    selected = position;
                 }
+                position++;
             }
-        });
+            final CheckedItemAdapter adapter = new CheckedItemAdapter(getActivity(), startModes);
+            adapter.setCheckedPosition(selected);
+            mListView.setAdapter(adapter);
+            mListView.setOnItemClickListener(new AdapterView.OnItemClickListener() {
+                @Override
+                public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
+                    adapter.setCheckedPosition(position);
+                    StartModeItem item = (StartModeItem) adapter.getItem(position);
+                    if (item != null) {
+                        onClick(item);
+                    }
+                }
+            });
 
-        sendIntent(AppConstants.INTENT_ACTION_TIME_HIDE);
+            sendIntent(AppConstants.INTENT_ACTION_TIME_HIDE);
+        }
     }
 
     @Override
@@ -128,10 +131,11 @@ public class LineStartModeFragment extends BaseFragment {
 
     public void onClick(StartModeItem startMode) {
         boolean sameFlag = false;
-        if (startMode.getFlag() == mProcedure.getStartModeFlag()) {
+        Flags flag = mLineStartProcedure.getStartModeFlag();
+        mLineStartProcedure.setStartModeFlag(MillisecondsTimePoint.now(), startMode.getFlag());
+        if (startMode.getFlag().equals(flag)) {
             sameFlag = true;
         }
-        mProcedure.setStartModeFlag(MillisecondsTimePoint.now(), startMode.getFlag());
         if (getArguments() != null && getArguments().getInt(START_MODE, START_MODE_PRESETUP) == START_MODE_PRESETUP) {
             openMainScheduleFragment();
         } else {

mobile/com.sap.sailing.racecommittee.app/src/com/sap/sailing/racecommittee/app/ui/utils/FlagsResources.java

@@ -105,6 +105,11 @@ public class FlagsResources {
             outline = outline.replace("XX", "01");
             break;
 
+        case OSCAR:
+            flag = "flag_oscar_" + size + "dp";
+            outline = outline.replace("XX", "01");
+            break;
+
         case PAPA:
             flag = "flag_papa_" + size + "dp";
             outline = outline.replace("XX", "01");