merge bug3916 into origin/master

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

@@ -1,32 +1,46 @@
 package com.sap.sailing.domain.common.racelog;
 
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Set;
 
+/**
+ * Flags for different purposes. Flags may qualify as start mode flags. See {@link #getStartModeFlags}.
+ * 
+ * @author Axel Uhl (d043530)
+ *
+ */
 public enum Flags {
-    NONE,
-    ALPHA,
-    BRAVO,
-    CLASS,
-    FOXTROTT,
-    GOLF,
-    HOTEL,
-    INDIA,
-    INDIA_ZULU, // the flag combination of I+Z flown at the same time
-    NOVEMBER,
-    OSCAR,
-    PAPA,
-    UNIFORM,
-    XRAY,
-    ZULU,
-    FIRSTSUBSTITUTE,
-    BLACK,
-    BLUE,
-    JURY,
-    AP,
-    ESSONE,
-    ESSTWO,
-    ESSTHREE;
+    NONE(/* start mode flag */ false),
+    ALPHA(/* start mode flag */ false),
+    BRAVO(/* start mode flag */ false),
+    CLASS(/* start mode flag */ false),
+    FOXTROTT(/* start mode flag */ false),
+    GOLF(/* start mode flag */ false),
+    HOTEL(/* start mode flag */ false),
+    INDIA(/* start mode flag */ true),
+    INDIA_ZULU(/* start mode flag */ true), // the flag combination of I+Z flown at the same time
+    NOVEMBER(/* start mode flag */ false),
+    OSCAR(/* start mode flag */ false),
+    PAPA(/* start mode flag */ true),
+    UNIFORM(/* start mode flag */ true),
+    XRAY(/* start mode flag */ false),
+    ZULU(/* start mode flag */ true),
+    FIRSTSUBSTITUTE(/* start mode flag */ false),
+    BLACK(/* start mode flag */ true),
+    BLUE(/* start mode flag */ false),
+    JURY(/* start mode flag */ false),
+    AP(/* start mode flag */ false),
+    ESSONE(/* start mode flag */ false),
+    ESSTWO(/* start mode flag */ false),
+    ESSTHREE(/* start mode flag */ false),
+    SWC_ZERO(/* start mode flag */ false),
+    SWC_ONE(/* start mode flag */ false),
+    SWC_TWO(/* start mode flag */ false),
+    SWC_THREE(/* start mode flag */ false),
+    SWC_FOUR(/* start mode flag */ false),
+    SWC_FIVE(/* start mode flag */ false);
     
     public static Flags[] validValues() {
         List<Flags> validValues = new ArrayList<Flags>();
@@ -37,4 +51,20 @@ public enum Flags {
         }
         return validValues.toArray(new Flags[validValues.size()]);
     }
+    
+    private Flags(boolean isStartModeFlag) {
+        this.isStartModeFlag = isStartModeFlag;
+    }
+    
+    public static Flags[] getStartModeFlags() {
+        return startModeFlags.toArray(new Flags[startModeFlags.size()]);
+    }
+
+    public boolean isStartModeFlag() {
+        return isStartModeFlag;
+    }
+    
+    private final boolean isStartModeFlag;
+    
+    private static Set<Flags> startModeFlags = new HashSet<>();
 }

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

@@ -1,64 +0,0 @@
-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 RRS26StartModeFlagFinder extends RaceLogAnalyzer<Flags> {
-
-    private final static List<Flags> defaultStartModeFlags = Arrays.asList(Flags.PAPA, Flags.ZULU, Flags.BLACK, Flags.INDIA, Flags.UNIFORM, Flags.INDIA_ZULU);
-    
-    private final RacingProcedureTypeAnalyzer procedureAnalyzer;
-    private final List<Flags> startModeFlags;
-
-    /**
-     * Searches for the start mode flag of a RRS26 race.
-     * 
-     * @param procedureAnalyzer
-     *            to be used to ensure a RRS26 race. Must operate on the same race log. Otherwise a
-     *            {@link IllegalArgumentException} is thrown.
-     */
-    public RRS26StartModeFlagFinder(RacingProcedureTypeAnalyzer procedureAnalyzer, RaceLog raceLog) {
-        this(procedureAnalyzer, raceLog, defaultStartModeFlags);
-    }
-    
-    public RRS26StartModeFlagFinder(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.RRS26.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/analyzing/impl/StartModeFlagFinder.java

@@ -1,6 +1,5 @@
 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;
@@ -9,25 +8,19 @@ 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> {
+public class StartModeFlagFinder 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.
+     * Searches for the start mode flags.
      * 
      * @param procedureAnalyzer
-     *            to be used to ensure a SWC race. Must operate on the same race log. Otherwise a
+     *            to be used to ensure a racing procedure with start mode flags. 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) {
+    public StartModeFlagFinder(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.");
@@ -39,7 +32,7 @@ public class SWCStartModeFlagFinder extends RaceLogAnalyzer<Flags> {
     @Override
     protected Flags performAnalysis() {
         RacingProcedureType type = procedureAnalyzer.analyze();
-        if (!RacingProcedureType.SWC.equals(type)) {
+        if (!(RacingProcedureType.RRS26.equals(type) || RacingProcedureType.SWC.equals(type))) {
             return null;
         }
         

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

@@ -9,10 +9,14 @@ public enum RaceStateEvents {
     RRS26_STARTMODE_UP,
     RRS26_STARTMODE_DOWN,
 
-    SWC_CLASS_OVER_OSCAR_UP,
-    SWC_STARTMODE_UP,
-    SWC_STARTMODE_DOWN,
-    SWC_CLASS_OVER_OSCAR_DOWN,
+    SWC_CLASS_AND_STARTMODE_UP,
+    SWC_CLASS_AND_STARTMODE_DOWN,
+    SWC_FIVE_UP,
+    SWC_FOUR_UP,
+    SWC_THREE_UP,
+    SWC_TWO_UP,
+    SWC_ONE_UP,
+    SWC_GREEN_UP,
 
     ESS_AP_DOWN,
     ESS_THREE_UP,

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

@@ -52,9 +52,13 @@ public interface ReadonlyRacingProcedure extends RaceStateEventProcessor, RaceSt
     void removeChangedListener(RacingProcedureChangedListener listener);
 
     /**
-     * Returns <code>true</code> if the start phase of this {@link ReadonlyRacingProcedure is active given the current time and start time.
-     * @param startTime start time to be used to determine whether the start phase is active or not.
-     * @param now {@link TimePoint} used as the current time on determining whether the start phase is active or not.
+     * Returns <code>true</code> if the start phase of this {@link ReadonlyRacingProcedure is active given the current
+     * time and start time.
+     * 
+     * @param startTime
+     *            start time to be used to determine whether the start phase is active or not. Must not be {@code null}
+     * @param now
+     *            {@link TimePoint} used as the current time on determining whether the start phase is active or not.
      */
     boolean isStartphaseActive(TimePoint startTime, TimePoint now);
 

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

@@ -1,5 +1,7 @@
 package com.sap.sailing.domain.abstractlog.race.state.racingprocedure.line;
 
+import java.util.List;
+
 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;
@@ -21,5 +23,7 @@ public interface ConfigurableStartModeFlagRacingProcedure extends RacingProcedur
     
     Flags getDefaultStartMode();
     
+    List<Flags> getDefaultStartModeFlags();
+    
     void setStartModeFlag(TimePoint timePoint, Flags startMode);
 }

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

@@ -1,10 +1,14 @@
 package com.sap.sailing.domain.abstractlog.race.state.racingprocedure.line;
 
+import java.util.Arrays;
+import java.util.List;
+
 import com.sap.sailing.domain.base.configuration.procedures.RRS26Configuration;
 import com.sap.sailing.domain.common.racelog.Flags;
 
 public interface RRS26RacingProcedure extends ConfigurableStartModeFlagRacingProcedure {
-    public final static Flags DefaultStartMode = Flags.PAPA;
-    
+    public final static Flags DEFAULT_START_MODE = Flags.PAPA;
+    public final static List<Flags> DEFAULT_START_MODE_FLAGS = Arrays.asList(Flags.PAPA, Flags.ZULU, Flags.BLACK, Flags.INDIA, Flags.UNIFORM, Flags.INDIA_ZULU);
+
     RRS26Configuration getConfiguration();
 }

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

@@ -1,11 +1,15 @@
 package com.sap.sailing.domain.abstractlog.race.state.racingprocedure.line;
 
+import java.util.Arrays;
+import java.util.List;
+
 import com.sap.sailing.domain.base.configuration.procedures.SWCStartConfiguration;
 import com.sap.sailing.domain.common.racelog.Flags;
 
 public interface SWCRacingProcedure extends ConfigurableStartModeFlagRacingProcedure {
 
-    public final static Flags DefaultStartMode = Flags.UNIFORM;
+    public final static Flags DEFAULT_START_MODE = Flags.UNIFORM;
+    public final static List<Flags> DEFAULT_START_MODE_FLAGS = Arrays.asList(Flags.BLACK, Flags.UNIFORM);
     
     SWCStartConfiguration getConfiguration();
 }

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

@@ -3,19 +3,83 @@ 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.analyzing.impl.RacingProcedureTypeAnalyzer;
+import com.sap.sailing.domain.abstractlog.race.analyzing.impl.StartModeFlagFinder;
+import com.sap.sailing.domain.abstractlog.race.impl.RaceLogFlagEventImpl;
 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.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.abstractlog.race.state.racingprocedure.line.LineStartChangedListener;
 import com.sap.sailing.domain.base.configuration.procedures.ConfigurableStartModeFlagRacingProcedureConfiguration;
+import com.sap.sailing.domain.common.racelog.Flags;
+import com.sap.sse.common.Duration;
+import com.sap.sse.common.TimePoint;
 
 public abstract class ConfigurableStartModeFlagRacingProcedureImpl extends BaseRacingProcedure implements ConfigurableStartModeFlagRacingProcedure {
     
+    protected Flags cachedStartmodeFlag;
+    private boolean startmodeFlagHasBeenSet;
+    private StartModeFlagFinder startModeFlagAnalyzer;
+
     public ConfigurableStartModeFlagRacingProcedureImpl(RaceLog raceLog, AbstractLogEventAuthor author,
-            RacingProcedureConfiguration configuration, RaceLogResolver raceLogResolver) {
+            ConfigurableStartModeFlagRacingProcedureConfiguration configuration, RaceLogResolver raceLogResolver) {
         super(raceLog, author, configuration, raceLogResolver);
+        
+        RacingProcedureTypeAnalyzer procedureAnalyzer = new RacingProcedureTypeAnalyzer(raceLog);
+        if (configuration.getStartModeFlags() != null) {
+            this.startModeFlagAnalyzer = new StartModeFlagFinder(procedureAnalyzer, raceLog, configuration.getStartModeFlags());
+        } else {
+            this.startModeFlagAnalyzer = new StartModeFlagFinder(procedureAnalyzer, raceLog, getDefaultStartModeFlags());
+        }
+        
+        this.cachedStartmodeFlag = getDefaultStartMode();
+        this.startmodeFlagHasBeenSet = false;
+        
+        update();
+    }
+
+    abstract protected Duration getStartPhaseStartModeUpInterval();
+
+    @Override
+    public boolean isStartphaseActive(TimePoint startTime, TimePoint now) {
+        return now.before(startTime) && !now.before(startTime.minus(getStartPhaseStartModeUpInterval()));
+    }
+
+    @Override
+    public RacingProcedurePrerequisite checkPrerequisitesForStart(TimePoint now, TimePoint startTime,
+            FulfillmentFunction function) {
+        if (startTime.minus(getStartPhaseStartModeUpInterval()).before(now) && !startmodeFlagHasBeenSet()) {
+            return new StartModePrerequisite(function, this, now, startTime);
+        }
+        return new NoMorePrerequisite(function);
+    }
+
+    public boolean startmodeFlagHasBeenSet() {
+        return startmodeFlagHasBeenSet;
+    }
+
+    @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
+    protected void update() {
+        Flags startmodeFlag = startModeFlagAnalyzer.analyze();
+        if (startmodeFlag != null && (!startmodeFlag.equals(cachedStartmodeFlag) || !startmodeFlagHasBeenSet)) {
+            cachedStartmodeFlag = startmodeFlag;
+            startmodeFlagHasBeenSet = true;
+            getChangedListeners().onStartModeChanged(this);
+        }
     }
 
     @Override

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

@@ -3,53 +3,37 @@ package com.sap.sailing.domain.abstractlog.race.state.racingprocedure.line.impl;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.List;
 
 import com.sap.sailing.domain.abstractlog.AbstractLogEventAuthor;
 import com.sap.sailing.domain.abstractlog.race.RaceLog;
-import com.sap.sailing.domain.abstractlog.race.analyzing.impl.RRS26StartModeFlagFinder;
 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.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.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.Duration;
 import com.sap.sse.common.TimePoint;
 
 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
-    private final static long startPhaseStartModeDownInterval = 1 * 60 * 1000; // minutes * seconds * milliseconds
-
-    private final RRS26StartModeFlagFinder startModeFlagAnalyzer;
-    
-    private Flags cachedStartmodeFlag;
-    private boolean startmodeFlagHasBeenSet;
+    private final static Duration startPhaseClassUpInterval = Duration.ONE_MINUTE.times(5);
+    private final static Duration startPhaseStartModeUpInterval = Duration.ONE_MINUTE.times(4);
+    private final static Duration startPhaseStartModeDownInterval = Duration.ONE_MINUTE;
 
     public RRS26RacingProcedureImpl(RaceLog raceLog, AbstractLogEventAuthor author, 
              RRS26Configuration configuration, RaceLogResolver raceLogResolver) {
         super(raceLog, author, configuration, raceLogResolver);
-        
-        RacingProcedureTypeAnalyzer procedureAnalyzer = new RacingProcedureTypeAnalyzer(raceLog);
-        if (configuration.getStartModeFlags() != null) {
-            this.startModeFlagAnalyzer = new RRS26StartModeFlagFinder(procedureAnalyzer, raceLog, configuration.getStartModeFlags());
-        } else {
-            this.startModeFlagAnalyzer = new RRS26StartModeFlagFinder(procedureAnalyzer, raceLog);
-        }
-        
-        this.cachedStartmodeFlag = RRS26RacingProcedure.DefaultStartMode;
-        this.startmodeFlagHasBeenSet = false;
-        
-        update();
+    }
+
+    @Override
+    protected Duration getStartPhaseStartModeUpInterval() {
+        return startPhaseStartModeUpInterval;
     }
 
     @Override
@@ -62,7 +46,7 @@ public class RRS26RacingProcedureImpl extends ConfigurableStartModeFlagRacingPro
         boolean hasRecall = super.hasIndividualRecall();
         if (!hasRecall) {
             return false;
-        } else if (startmodeFlagHasBeenSet) {
+        } else if (startmodeFlagHasBeenSet()) {
             return cachedStartmodeFlag != Flags.BLACK;
         } else {
             return hasRecall;
@@ -79,24 +63,6 @@ public class RRS26RacingProcedureImpl extends ConfigurableStartModeFlagRacingPro
         return false;
     }
 
-    @Override
-    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 NoMorePrerequisite(function);
-    }
-
-    @Override
-    public boolean isStartphaseActive(TimePoint startTime, TimePoint now) {
-        if (now.before(startTime)) {
-            long timeTillStart = startTime.minus(now.asMillis()).asMillis();
-            return timeTillStart < startPhaseClassUpInterval;
-        }
-        return false;
-    }
-
     @Override
     protected Collection<RaceStateEvent> createStartStateEvents(TimePoint startTime) {
         return Arrays.<RaceStateEvent> asList(
@@ -110,7 +76,7 @@ public class RRS26RacingProcedureImpl extends ConfigurableStartModeFlagRacingPro
     public boolean processStateEvent(RaceStateEvent event) {
         switch (event.getEventName()) {
         case RRS26_STARTMODE_UP:
-            if (!startmodeFlagHasBeenSet) {
+            if (!startmodeFlagHasBeenSet()) {
                 setStartModeFlag(event.getTimePoint(), cachedStartmodeFlag);
             }
         case RRS26_CLASS_UP:
@@ -173,39 +139,18 @@ public class RRS26RacingProcedureImpl extends ConfigurableStartModeFlagRacingPro
         }
     }
     
-    @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 RRS26RacingProcedure.DefaultStartMode;
+        return RRS26RacingProcedure.DEFAULT_START_MODE;
     }
 
-    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();
+    public List<Flags> getDefaultStartModeFlags() {
+        return RRS26RacingProcedure.DEFAULT_START_MODE_FLAGS;
     }
-    
+
     @Override
     public RRS26Configuration getConfiguration() {
         return (RRS26Configuration) super.getConfiguration();
     }
-
 }

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

@@ -3,52 +3,41 @@ package com.sap.sailing.domain.abstractlog.race.state.racingprocedure.line.impl;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.List;
 
 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.SWCStartConfiguration;
 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.Duration;
 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;
+    private final static Duration CLASS_AND_STARTMODE_UP_INTERVAL = Duration.ONE_MINUTE.times(6); // 6 minutes before start
+    private final static Duration CLASS_AND_STARTMODE_DOWN_INTERVAL = Duration.ONE_MINUTE; // 1 minute after start
+    private final static Duration FIVE_MINUTES_FLAG_UP_INTERVAL = Duration.ONE_MINUTE.times(5); // 5 minutes before start
+    private final static Duration FOUR_MINUTES_FLAG_UP_INTERVAL = Duration.ONE_MINUTE.times(4); // 4 minutes before start
+    private final static Duration THREE_MINUTES_FLAG_UP_INTERVAL = Duration.ONE_MINUTE.times(3); // 3 minutes before start
+    private final static Duration TWO_MINUTES_FLAG_UP_INTERVAL = Duration.ONE_MINUTE.times(2); // 2 minutes before start
+    private final static Duration ONE_MINUTE_FLAG_UP_INTERVAL = Duration.ONE_MINUTE; // 1 minutes before start
 
     public SWCRacingProcedureImpl(RaceLog raceLog, AbstractLogEventAuthor author, 
              SWCStartConfiguration 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
+    protected Duration getStartPhaseStartModeUpInterval() {
+        return CLASS_AND_STARTMODE_UP_INTERVAL;
     }
 
     @Override
@@ -61,7 +50,7 @@ public class SWCRacingProcedureImpl extends ConfigurableStartModeFlagRacingProce
         boolean hasRecall = super.hasIndividualRecall();
         if (!hasRecall) {
             return false;
-        } else if (startmodeFlagHasBeenSet) {
+        } else if (startmodeFlagHasBeenSet()) {
             return cachedStartmodeFlag != Flags.BLACK;
         } else {
             return hasRecall;
@@ -78,37 +67,34 @@ public class SWCRacingProcedureImpl extends ConfigurableStartModeFlagRacingProce
         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.minus(CLASS_AND_STARTMODE_UP_INTERVAL), RaceStateEvents.SWC_CLASS_AND_STARTMODE_UP),
+                new RaceStateEventImpl(startTime.minus(FIVE_MINUTES_FLAG_UP_INTERVAL), RaceStateEvents.SWC_FIVE_UP),
+                new RaceStateEventImpl(startTime.minus(FOUR_MINUTES_FLAG_UP_INTERVAL), RaceStateEvents.SWC_FOUR_UP),
+                new RaceStateEventImpl(startTime.minus(THREE_MINUTES_FLAG_UP_INTERVAL), RaceStateEvents.SWC_THREE_UP),
+                new RaceStateEventImpl(startTime.minus(TWO_MINUTES_FLAG_UP_INTERVAL), RaceStateEvents.SWC_TWO_UP),
+                new RaceStateEventImpl(startTime.minus(ONE_MINUTE_FLAG_UP_INTERVAL), RaceStateEvents.SWC_ONE_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));
+                new RaceStateEventImpl(startTime, RaceStateEvents.SWC_GREEN_UP),
+                new RaceStateEventImpl(startTime.plus(CLASS_AND_STARTMODE_DOWN_INTERVAL), RaceStateEvents.SWC_CLASS_AND_STARTMODE_DOWN));
     }
 
     @Override
     public boolean processStateEvent(RaceStateEvent event) {
         switch (event.getEventName()) {
-        case SWC_STARTMODE_UP:
-            if (!startmodeFlagHasBeenSet) {
+        case SWC_CLASS_AND_STARTMODE_UP:
+            if (!startmodeFlagHasBeenSet()) {
                 setStartModeFlag(event.getTimePoint(), cachedStartmodeFlag);
             }
-        case SWC_CLASS_OVER_OSCAR_UP:
-        case SWC_STARTMODE_DOWN:
-        case SWC_CLASS_OVER_OSCAR_DOWN:
+        case SWC_CLASS_AND_STARTMODE_DOWN:
+        case SWC_FIVE_UP:
+        case SWC_FOUR_UP:
+        case SWC_THREE_UP:
+        case SWC_TWO_UP:
+        case SWC_ONE_UP:
+        case SWC_GREEN_UP:
             getChangedListeners().onActiveFlagsChanged(this);
             return true;
         default:
@@ -118,21 +104,54 @@ public class SWCRacingProcedureImpl extends ConfigurableStartModeFlagRacingProce
 
     @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))) {
+        if (now.before(startTime.minus(CLASS_AND_STARTMODE_UP_INTERVAL))) {
             return new FlagPoleState(
-                    Arrays.asList(new FlagPole(classFlag, Flags.OSCAR, false), new FlagPole(cachedStartmodeFlag, false)),
+                    Arrays.asList(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))) {
+                    Arrays.asList(new FlagPole(cachedStartmodeFlag, true)), 
+                    startTime.minus(CLASS_AND_STARTMODE_UP_INTERVAL));
+        } else if (now.before(startTime.minus(FIVE_MINUTES_FLAG_UP_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));
+                    Arrays.asList(new FlagPole(cachedStartmodeFlag, true), new FlagPole(Flags.SWC_FIVE, false)),
+                    startTime.minus(CLASS_AND_STARTMODE_UP_INTERVAL),
+                    Arrays.asList(new FlagPole(cachedStartmodeFlag, true), new FlagPole(Flags.SWC_FIVE, true)), 
+                    startTime.minus(FIVE_MINUTES_FLAG_UP_INTERVAL));
+        } else if (now.before(startTime.minus(FOUR_MINUTES_FLAG_UP_INTERVAL))) {
+            return new FlagPoleState(
+                    Arrays.asList(new FlagPole(cachedStartmodeFlag, true), new FlagPole(Flags.SWC_FIVE, true), new FlagPole(Flags.SWC_FOUR, false)),
+                    startTime.minus(FIVE_MINUTES_FLAG_UP_INTERVAL),
+                    Arrays.asList(new FlagPole(cachedStartmodeFlag, true), new FlagPole(Flags.SWC_FOUR, true), new FlagPole(Flags.SWC_THREE, false)), 
+                    startTime.minus(FOUR_MINUTES_FLAG_UP_INTERVAL));
+        } else if (now.before(startTime.minus(THREE_MINUTES_FLAG_UP_INTERVAL))) {
+            return new FlagPoleState(
+                    Arrays.asList(new FlagPole(cachedStartmodeFlag, true), new FlagPole(Flags.SWC_FOUR, true), new FlagPole(Flags.SWC_THREE, false)),
+                    startTime.minus(FOUR_MINUTES_FLAG_UP_INTERVAL),
+                    Arrays.asList(new FlagPole(cachedStartmodeFlag, true), new FlagPole(Flags.SWC_THREE, true), new FlagPole(Flags.SWC_TWO, false)), 
+                    startTime.minus(THREE_MINUTES_FLAG_UP_INTERVAL));
+        } else if (now.before(startTime.minus(TWO_MINUTES_FLAG_UP_INTERVAL))) {
+            return new FlagPoleState(
+                    Arrays.asList(new FlagPole(cachedStartmodeFlag, true), new FlagPole(Flags.SWC_THREE, true), new FlagPole(Flags.SWC_TWO, false)),
+                    startTime.minus(THREE_MINUTES_FLAG_UP_INTERVAL),
+                    Arrays.asList(new FlagPole(cachedStartmodeFlag, true), new FlagPole(Flags.SWC_TWO, true), new FlagPole(Flags.SWC_ONE, false)), 
+                    startTime.minus(TWO_MINUTES_FLAG_UP_INTERVAL));
+        } else if (now.before(startTime.minus(ONE_MINUTE_FLAG_UP_INTERVAL))) {
+            return new FlagPoleState(
+                    Arrays.asList(new FlagPole(cachedStartmodeFlag, true), new FlagPole(Flags.SWC_TWO, true), new FlagPole(Flags.SWC_ONE, false)),
+                    startTime.minus(TWO_MINUTES_FLAG_UP_INTERVAL),
+                    Arrays.asList(new FlagPole(cachedStartmodeFlag, true), new FlagPole(Flags.SWC_ONE, true), new FlagPole(Flags.SWC_ZERO, false)), 
+                    startTime.minus(ONE_MINUTE_FLAG_UP_INTERVAL));
+        } else if (now.before(startTime)) {
+            return new FlagPoleState(
+                    Arrays.asList(new FlagPole(cachedStartmodeFlag, true), new FlagPole(Flags.SWC_ONE, true), new FlagPole(Flags.SWC_ZERO, false)),
+                    startTime.minus(ONE_MINUTE_FLAG_UP_INTERVAL),
+                    Arrays.asList(new FlagPole(cachedStartmodeFlag, true), new FlagPole(Flags.SWC_ZERO, true)), 
+                    startTime);
+        } else if (now.before(startTime.plus(CLASS_AND_STARTMODE_DOWN_INTERVAL))) {
+            return new FlagPoleState(
+                    Arrays.asList(new FlagPole(cachedStartmodeFlag, true), new FlagPole(Flags.SWC_ZERO, true)),
+                    startTime,
+                    Arrays.asList(new FlagPole(cachedStartmodeFlag, false), new FlagPole(Flags.SWC_ZERO, false)), 
+                    startTime.plus(CLASS_AND_STARTMODE_DOWN_INTERVAL));
         } else {
             if (isIndividualRecallDisplayed(now)) {
                 return new FlagPoleState(
@@ -151,44 +170,23 @@ public class SWCRacingProcedureImpl extends ConfigurableStartModeFlagRacingProce
                         null);
             } else {
                 TimePoint recallRemoved = getIndividualRecallRemovalTime();
-                return new FlagPoleState(Collections.<FlagPole>emptyList(), recallRemoved == null ? startTime : recallRemoved);
+                return new FlagPoleState(Collections.<FlagPole>emptyList(), recallRemoved == null ? startTime.plus(CLASS_AND_STARTMODE_DOWN_INTERVAL) : 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;
+        return SWCRacingProcedure.DEFAULT_START_MODE;
     }
 
-    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();
+    public List<Flags> getDefaultStartModeFlags() {
+        return SWCRacingProcedure.DEFAULT_START_MODE_FLAGS;
     }
-    
+
     @Override
     public SWCStartConfiguration getConfiguration() {
         return (SWCStartConfiguration) super.getConfiguration();
     }
-
 }

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

@@ -8,5 +8,4 @@ import com.sap.sailing.domain.common.racelog.Flags;
 public interface ConfigurableStartModeFlagRacingProcedureConfiguration extends RacingProcedureConfiguration {
     
     List<Flags> getStartModeFlags();
-
 }

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

@@ -39,6 +39,12 @@ public class FlagImageResolver {
         flagImageMap.put(Flags.XRAY, resources.flagXray());
         flagImageMap.put(Flags.ZULU, resources.flagZulu());
         flagImageMap.put(Flags.OSCAR, resources.flagOscar());
+        flagImageMap.put(Flags.SWC_ZERO, resources.flagSWCZero());
+        flagImageMap.put(Flags.SWC_ONE, resources.flagSWCOne());
+        flagImageMap.put(Flags.SWC_TWO, resources.flagSWCTwo());
+        flagImageMap.put(Flags.SWC_THREE, resources.flagSWCThree());
+        flagImageMap.put(Flags.SWC_FOUR, resources.flagSWCFour());
+        flagImageMap.put(Flags.SWC_FIVE, resources.flagSWCFive());
     }
     
     public ImageResource resolveFlagToImage(Flags flag, boolean isDisplayed, boolean displayStateChanged) {

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

@@ -72,4 +72,22 @@ interface RegattaRaceStatesFlagsResources extends ClientBundle {
     
     @Source("com/sap/sailing/gwt/ui/client/images/flags/flags_racecommittee/down.png")
     ImageResource arrowDown();
+
+    @Source("com/sap/sailing/gwt/ui/client/images/flags/flags_racecommittee/swc_zero.png")
+    ImageResource flagSWCZero();
+
+    @Source("com/sap/sailing/gwt/ui/client/images/flags/flags_racecommittee/swc_one.png")
+    ImageResource flagSWCOne();
+
+    @Source("com/sap/sailing/gwt/ui/client/images/flags/flags_racecommittee/swc_two.png")
+    ImageResource flagSWCTwo();
+
+    @Source("com/sap/sailing/gwt/ui/client/images/flags/flags_racecommittee/swc_three.png")
+    ImageResource flagSWCThree();
+
+    @Source("com/sap/sailing/gwt/ui/client/images/flags/flags_racecommittee/swc_four.png")
+    ImageResource flagSWCFour();
+
+    @Source("com/sap/sailing/gwt/ui/client/images/flags/flags_racecommittee/swc_five.png")
+    ImageResource flagSWCFive();
 }

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

@@ -68,7 +68,13 @@ public final class ListBoxUtils {
         setupFlagsListBox(box, selectedFlags, Flags.validValues());
     }
 
-    public static void setupStartmodeFlagsListBox(ListBox box, List<Flags> selectedFlags) {
-        setupFlagsListBox(box, selectedFlags, Flags.PAPA, Flags.BLACK, Flags.INDIA, Flags.INDIA_ZULU, Flags.UNIFORM);            
+    public static void setupRRS26StartmodeFlagsListBox(ListBox box, List<Flags> selectedFlags) {
+        setupFlagsListBox(box, selectedFlags, Flags.getStartModeFlags());            
     }
+    
+    public static void setupSWCStartmodeFlagsListBox(ListBox box, List<Flags> selectedFlags) {
+        // the SWC racing procedure restricts the possible start modes to BLACK and UNIFORM, eliminating INDIA / ZULU combinations as well as PAPA
+        setupFlagsListBox(box, selectedFlags, Flags.BLACK, Flags.UNIFORM);
+    }
+
 }

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

@@ -248,7 +248,7 @@ public class RegattaConfigurationDialog extends DataEntryDialog<DeviceConfigurat
                 && originalConfiguration.rrs26Configuration.startModeFlags != null) {
             selectedFlags = originalConfiguration.rrs26Configuration.startModeFlags;
         }
-        ListBoxUtils.setupStartmodeFlagsListBox(rrs26StartModeFlagsBox, selectedFlags);
+        ListBoxUtils.setupRRS26StartmodeFlagsListBox(rrs26StartModeFlagsBox, selectedFlags);
         rrs26StartModeFlagsBox.addChangeHandler(new ChangeHandler() {
             @Override
             public void onChange(ChangeEvent event) {
@@ -308,7 +308,7 @@ public class RegattaConfigurationDialog extends DataEntryDialog<DeviceConfigurat
                 && originalConfiguration.swcStartConfiguration.startModeFlags != null) {
             selectedFlags = originalConfiguration.swcStartConfiguration.startModeFlags;
         }
-        ListBoxUtils.setupStartmodeFlagsListBox(swcStartModeFlagsBox, selectedFlags);
+        ListBoxUtils.setupSWCStartmodeFlagsListBox(swcStartModeFlagsBox, selectedFlags);
         swcStartModeFlagsBox.addChangeHandler(new ChangeHandler() {
             @Override
             public void onChange(ChangeEvent event) {