GitLab

at 2023-11-22T10:36:58+01:00

sort items in legend

add new entries in TripMapPointType

get logbook activities with sampling and use new entries of TripMapPointType in TripMapBuilder

add new configuration option for logbook activities with sampling (default is yellow)

update TripMapContentBuilder and ps style to use new type of point (with sampling)

add suppressWarning for services with generics and AutoService annotation usage

change shortcut (Alt + Fxx is used under linux by X)

Merge branch 'feature/issue-2549' into develop
Mettre en exergue sur la carte les calées qui ont été échantillonnées - See

add suppressWarning for services with generics and AutoService annotation usage

fix french I18n legendBottom and legendTop are reversed....

add validCount and notValidCount in ObserveMapPaneLegendItem (o be able to compute real label at runtime)

add addPointCount option in ObserveMapPane and use it to compute legend label

add AddPointCount action to switch addPointCount option

Merge branch 'feature/issue-2805' into develop
Ajouter une option pour voir le nombre de points dans la légende - Closes

 type = color

 defaultValue = java.awt.Color[r=255,g=0,b=0]

+[option mapPsStyleLogbookWithSamplingPointColor]

+description = observe.config.map.ps.style.logbook.withSampling.point.color

+key = ui.map.ps.style.logbook.withSampling.point.color

+type = color

+defaultValue = java.awt.Color[r=255,g=255,b=0]

+

 [option mapPsStyleLogbookTextColor]

 description = observe.config.map.ps.style.logbook.text.color

 key = ui.map.ps.style.logbook.text.color

 observe.config.map.ps.style.logbook.text.color

 observe.config.map.ps.style.logbook.text.size

 observe.config.map.ps.style.logbook.transmitting.buoy.lost.point.color

+observe.config.map.ps.style.logbook.withSampling.point.color

 observe.config.map.ps.style.observations.line.color

 observe.config.map.ps.style.observations.point.color

 observe.config.map.ps.style.observations.text.color

  *

  * @author Tony Chemit - dev@tchemit.fr

  */

+@SuppressWarnings("rawtypes")

 @AutoService(NuitonConverter.class)

 public class SeineBycatchObservedSystemConfigConverter implements NuitonConverter<SeineBycatchObservedSystemConfig> {

  * @author Tony Chemit - dev@tchemit.fr

  * @since ?

  */

+@SuppressWarnings("rawtypes")

 @AutoService(MainUIBodyContent.class)

 public class H2ServerBodyContent extends MainUIBodyContent<H2ServerUI> implements WithClientUIContextApi {

  * @author Tony Chemit - dev@tchemit.fr

  * @since 8

  */

+@SuppressWarnings("rawtypes")

 @AutoService(MainUIBodyContent.class)

 public class RemotePresetsBodyContent extends MainUIBodyContent<RemotePresetsUI> {

  * @author Tony Chemit - dev@tchemit.fr

  * @since 8

  */

+@SuppressWarnings("rawtypes")

 @AutoService(MainUIBodyContent.class)

 public class ClientConfigBodyContent extends MainUIBodyContent<ClientConfigUI> implements WithClientUIContextApi {

         helper.addOption(ClientConfigOption.MAP_PS_STYLE_LOGBOOK_TEXT_SIZE);

         helper.addOption(ClientConfigOption.MAP_PS_STYLE_LOGBOOK_LINE_COLOR);

         helper.addOption(ClientConfigOption.MAP_PS_STYLE_LOGBOOK_POINT_COLOR);

+        helper.addOption(ClientConfigOption.MAP_PS_STYLE_LOGBOOK_WITH_SAMPLING_POINT_COLOR);

         helper.addOption(ClientConfigOption.MAP_PS_STYLE_LOGBOOK_TRANSMITTING_BUOY_LOST_POINT_COLOR);

         helper.addOption(ClientConfigOption.MAP_LL_STYLE_FILE);

         helper.addOption(ClientConfigOption.MAP_LL_STYLE_OBSERVATIONS_LINE_TRIP_COLOR);

  * @author Tony Chemit - dev@tchemit.fr

  * @since 8

  */

+@SuppressWarnings("rawtypes")

 @AutoService(MainUIBodyContent.class)

 public class NoBodyContent extends MainUIBodyContent<NoBodyContentComponent> {

  * @author Tony Chemit - dev@tchemit.fr

  * @since 8

  */

+@SuppressWarnings("rawtypes")

 @AutoService(MainUIBodyContent.class)

 public class AdminUIBodyContent extends MainUIBodyContent<AdminUI> implements WithClientUIContextApi {

 observe.ui.datasource.editor.content.map.action.zoomMoins.tip

 observe.ui.datasource.editor.content.map.action.zoomPlus

 observe.ui.datasource.editor.content.map.action.zoomPlus.tip

+observe.ui.datasource.editor.content.map.addPointCount

 observe.ui.datasource.editor.content.map.east

 observe.ui.datasource.editor.content.map.export.chooseFile.ok

 observe.ui.datasource.editor.content.map.export.chooseFile.png

 observe.ui.datasource.editor.content.map.export.success

 observe.ui.datasource.editor.content.map.legend

 observe.ui.datasource.editor.content.map.legend.not.valid.count

+observe.ui.datasource.editor.content.map.legend.not.valid.counts

 observe.ui.datasource.editor.content.map.legend.tip

+observe.ui.datasource.editor.content.map.legend.valid.count

+observe.ui.datasource.editor.content.map.legend.valid.counts

 observe.ui.datasource.editor.content.map.legendBottom

 observe.ui.datasource.editor.content.map.legendBottom.tip

 observe.ui.datasource.editor.content.map.legendTop

  * @author Tony Chemit - dev@tchemit.fr

  * @since 8

  */

+@SuppressWarnings("rawtypes")

 @AutoService(MainUIBodyContent.class)

 public class DataSourceEditorBodyContent extends MainUIBodyContent<DataSourceEditor> implements WithClientUIContextApi {

     //FIXME Let's design a nice new API to register KeyStroke (a new annotation, processed to generate KeyStroke resources)

     // Navigation

-    public static final KeyStroke KEY_STROKE_MAP_CONFIGURE = KeyStroke.getKeyStroke("alt pressed F2");

+    public static final KeyStroke KEY_STROKE_MAP_CONFIGURE = KeyStroke.getKeyStroke("ctrl pressed F2");

     public static final KeyStroke KEY_STROKE_NAVIGATION_CONFIGURE = KeyStroke.getKeyStroke("pressed F12");

     public static final KeyStroke KEY_STROKE_STORAGE_MENU_LEFT = KeyStroke.getKeyStroke("pressed F1");

     public static final KeyStroke KEY_STROKE_SHOW_OBS = KeyStroke.getKeyStroke("ctrl pressed O");

     public static final KeyStroke KEY_STROKE_SHOW_OBSERVATIONS_TRIP_SEGMENT = KeyStroke.getKeyStroke("shift ctrl pressed O");

+    public static final KeyStroke KEY_STROKE_SHOW_POINT_COUNT = KeyStroke.getKeyStroke("ctrl pressed P");

     public static final KeyStroke KEY_STROKE_SHOW_LOGBOOK = KeyStroke.getKeyStroke("ctrl pressed L");

     public static final KeyStroke KEY_STROKE_SHOW_LOGBOOK_TRIP_SEGMENT = KeyStroke.getKeyStroke("shift ctrl pressed L");

     public static final KeyStroke KEY_STROKE_LEGEND_TOGGLE = KeyStroke.getKeyStroke("pressed F11");

  * @author Tony Chemit - dev@tchemit.fr

  */

 public class ObserveMapPane extends JMapPane {

-

+    public static final String PROPERTY_ADD_POINT_COUNT = "addPointCount";

     protected static final int MARGIN = 10;

     protected static final int SCALE_HEIGHT = 15;

     protected static final int SCALE_WIDTH_MAX = 200;

     private long scaleInMiles;

     private boolean showLegend = true;

     private LegendPosition legendPosition = LegendPosition.BOTTOM;

+    private boolean addPointCount = true;

     public enum LegendPosition {

         TOP, BOTTOM

     public boolean isLegendPositionBottom() {

         return getLegendPosition()==LegendPosition.BOTTOM;

     }

+

+

+    public boolean isAddPointCount() {

+        return addPointCount;

+    }

+

+    public void setAddPointCount(boolean addPointCount) {

+        boolean oldValue = isAddPointCount();

+        this.addPointCount = addPointCount;

+        firePropertyChange(PROPERTY_ADD_POINT_COUNT, oldValue, addPointCount);

+    }

+

     protected void updateScale() {

         ReferencedEnvelope displayArea = getDisplayArea();

         double dpi = 2.54 / 100; // pour avoir l'echélle en metre/pixel

             int maxLabelWidth = 0;

             for (ObserveMapPaneLegendItem item : legendItems) {

-                Rectangle2D labelArea = fm.getStringBounds(item.getLabel(), graphics);

+                Rectangle2D labelArea = fm.getStringBounds(item.getLabel(addPointCount), graphics);

                 maxLabelWidth = Math.max((int) labelArea.getWidth(), maxLabelWidth);

                 int labelMarginBottom = ((ObserveMapPaneLegendItem.LEGEND_ITEM_HEIGHT - fm.getHeight()) / 2) + fm.getDescent();

-                graphics.drawString(item.getLabel(),

+                graphics.drawString(item.getLabel(addPointCount),

                                     x + LEGEND_MARGIN + ObserveMapPaneLegendItem.LEGEND_SYMBOL_WIDTH,

                                     y + ObserveMapPaneLegendItem.LEGEND_ITEM_HEIGHT - labelMarginBottom);

  * #L%

  */

+import io.ultreia.java4all.i18n.I18n;

 import org.geotools.styling.Style;

 import org.locationtech.jts.geom.Coordinate;

 import org.opengis.feature.simple.SimpleFeature;

     protected static final int LEGEND_SYMBOL_WIDTH = 50;

     protected static final int LEGEND_MARGIN = 5;

     protected static final Color LEGEND_BACKGROUND = new Color(1f, 1f, 1f, 0.8f);

-    protected SimpleFeature simpleFeature;

-    protected Style style;

-    protected String label;

+    protected final SimpleFeature simpleFeature;

+    protected final Style style;

+    protected final String label;

+    protected final int notValidCount;

+    protected final int validCount;

-    public ObserveMapPaneLegendItem(SimpleFeature simpleFeature, Style style, String label) {

+    public ObserveMapPaneLegendItem(SimpleFeature simpleFeature, Style style, String label, int notValidCount, int validCount) {

         this.simpleFeature = simpleFeature;

         this.style = style;

         this.label = label;

+        this.notValidCount = notValidCount;

+        this.validCount = validCount;

     }

     public static Coordinate[] lineCoordinates() {

         return simpleFeature;

     }

-    public void setSimpleFeature(SimpleFeature simpleFeature) {

-        this.simpleFeature = simpleFeature;

-    }

-

     public Style getStyle() {

         return style;

     }

-    public void setStyle(Style style) {

-        this.style = style;

-    }

+    public String getLabel(boolean addPointCount) {

+        String label = this.label;

+        if (addPointCount && validCount > 0) {

+            if (validCount == 1) {

+                label += " " + I18n.t("observe.ui.datasource.editor.content.map.legend.valid.count", validCount);

+            } else {

+                label += " " + I18n.t("observe.ui.datasource.editor.content.map.legend.valid.counts", validCount);

+            }

+        }

+        if (notValidCount > 0) {

+            if (notValidCount == 1) {

+                label += " " + I18n.t("observe.ui.datasource.editor.content.map.legend.not.valid.count", notValidCount);

+            } else {

+                label += " " + I18n.t("observe.ui.datasource.editor.content.map.legend.not.valid.counts", notValidCount);

-    public String getLabel() {

+            }

+        }

         return label;

     }

-

-    public void setLabel(String label) {

-        this.label = label;

-    }

 }
 import java.text.SimpleDateFormat;

 import java.util.ArrayList;

 import java.util.Arrays;

+import java.util.Comparator;

 import java.util.Date;

 import java.util.EnumMap;

-import java.util.HashSet;

 import java.util.LinkedHashSet;

 import java.util.LinkedList;

 import java.util.List;

 import java.util.Map;

 import java.util.Optional;

 import java.util.Set;

+import java.util.stream.Collectors;

 /**

  * @author Tony Chemit - dev@tchemit.fr

     protected static SimpleDateFormat DATE_FORMAT = new SimpleDateFormat("MM-dd");

     protected final List<ObserveMapPaneLegendItem> legendItems;

+    protected final Map<TripMapPointType, List<TripMapPoint>> validPoints = new EnumMap<>(TripMapPointType.class);

     protected final Map<TripMapPointType, List<TripMapPoint>> notValidPoints = new EnumMap<>(TripMapPointType.class);

     protected final Set<TripMapPointType> acceptedTripPointTypes;

     protected final SimpleFeatureBuilder lineBuilder;

     @Override

     public void reset() {

         legendItems.clear();

+        validPoints.clear();

         notValidPoints.clear();

         if (mapContent != null) {

             mapContent.dispose();

         pointBuilder.add(formatDate(tripMapPoint.getTime()));

         pointBuilder.add(tripMapPoint.getType().name());

         pointsFeatures.add(pointBuilder.buildFeature(null));

+        validPoints.computeIfAbsent(tripMapPoint.getType(), e -> new LinkedList<>()).add(tripMapPoint);

     }

     public void addPoints(List<TripMapPoint> tripMapPoints, String layerName, String notValidPointsLabel) {

         DefaultFeatureCollection pointsFeatures = new DefaultFeatureCollection();

         Style stylePoints = findStyle(styledLayerDescriptor, layerName);

-        Set<TripMapPointType> pointTypeInLegend = new HashSet<>();

         for (TripMapPoint tripMapPoint : tripMapPoints) {

             if (tripMapPoint.isValid()) {

                 addPoint(pointsFeatures, tripMapPoint);

-                pointTypeInLegend.add(tripMapPoint.getType());

             } else {

                 notValidPoints.computeIfAbsent(tripMapPoint.getType(), e -> new LinkedList<>()).add(tripMapPoint);

             }

         }

-        pointTypeInLegend.retainAll(acceptedTripPointTypes);

         if (!pointsFeatures.isEmpty()) {

             Layer pointsLayer = new FeatureLayer(pointsFeatures, stylePoints, layerName);

             mapContent.addLayer(pointsLayer);

         }

+        Set<TripMapPointType> pointTypeInLegend = validPoints.keySet();

+        pointTypeInLegend.retainAll(acceptedTripPointTypes);

-        Set<TripMapPointType> notValidTypes = new LinkedHashSet<>(notValidPoints.keySet());

+        Set<TripMapPointType> notValidTypes = notValidPoints.keySet().stream().sorted(Comparator.comparing(TripMapPointType::getLabel)).collect(Collectors.toCollection(LinkedHashSet::new));

-        for (TripMapPointType type : pointTypeInLegend) {

+        List<TripMapPointType> sortedPointTypeInLegend = pointTypeInLegend.stream().sorted(Comparator.comparing(TripMapPointType::getLabel)).collect(Collectors.toList());

+        for (TripMapPointType type : sortedPointTypeInLegend) {

             List<TripMapPoint> notValidPointsForType = notValidPoints.get(type);

+            List<TripMapPoint> validPointsForType = validPoints.get(type);

+            int notValidCount = notValidPointsForType == null ? 0 : notValidPointsForType.size();

+            int validCount = validPointsForType == null ? 0 : validPointsForType.size();

             String label = type.getLabel();

-            if (notValidPointsForType != null && !notValidPointsForType.isEmpty()) {

-                label += " " + I18n.t("observe.ui.datasource.editor.content.map.legend.not.valid.count", notValidPointsForType.size());

+            if (notValidCount > 0) {

                 notValidTypes.remove(type);

             }

-            addPointLegend(stylePoints, type.name(), label);

+            addPointLegend(stylePoints, type.name(), label, notValidCount, validCount);

         }

         if (!notValidTypes.isEmpty()) {

             for (TripMapPointType type : notValidTypes) {

                 List<TripMapPoint> notValidPointsForType = notValidPoints.get(type);

                 String label = I18n.t(notValidPointsLabel, notValidPointsForType.size()) + " - " + type.getLabel();

-                addPointLegend(stylePoints, "notValidPoint", label);

+                addPointLegend(stylePoints, "notValidPoint", label, 0, 0);

             }

         }

     }

         }

         lineBuilder.add(legendName);

         SimpleFeature simpleFeature = lineBuilder.buildFeature(null);

-        ObserveMapPaneLegendItem legendTripDay = new ObserveMapPaneLegendItem(simpleFeature, styleLines, legendLabel);

+        ObserveMapPaneLegendItem legendTripDay = new ObserveMapPaneLegendItem(simpleFeature, styleLines, legendLabel, 0, 0);

         legendItems.add(legendTripDay);

     }

-    protected void addPointLegend(Style stylePoints, String legendName, String legendLabel) {

+    protected void addPointLegend(Style stylePoints, String legendName, String legendLabel, int notValidCount, int validCount) {

         Point point = getGeometryFactory().createPoint(ObserveMapPaneLegendItem.pointCoordinates());

         pointBuilder.add(point);

         pointBuilder.add("");

         pointBuilder.add(legendName);

         SimpleFeature simpleFeature = pointBuilder.buildFeature(null);

-        ObserveMapPaneLegendItem legendPoint = new ObserveMapPaneLegendItem(simpleFeature, stylePoints, legendLabel);

+        ObserveMapPaneLegendItem legendPoint = new ObserveMapPaneLegendItem(simpleFeature, stylePoints, legendLabel, notValidCount, validCount);

         legendItems.add(legendPoint);

     }

 }
   <import>

     fr.ird.observe.dto.data.TripMapConfigDto

     java.awt.CardLayout

+    java.util.Objects

   </import>

   <CardLayout id="contentLayout"/>

       <JCheckBoxMenuItem id='toggleLegend'/>

       <JRadioButtonMenuItem id='legendPositionTop' styleClass='legendPosition'/>

       <JRadioButtonMenuItem id='legendPositionBottom' styleClass='legendPosition'/>

+      <JCheckBoxMenuItem id='addPointCount'/>

     </JToolBar>

   </JPanel>

 }

 .legendPosition {

-  buttonGroup:"legendPosition";

-  enabled:{toggleLegend.isSelected()};

+  buttonGroup: legendPosition;

 }

 #legendPositionTop {

   selected:{observeMapPane.isLegendPositionTop()};

-  enabled:{observeMapPane.isLegendPositionBottom()}

+  enabled:{observeMapPane.isShowLegend() && observeMapPane.isLegendPositionBottom()}

 }

 #legendPositionBottom {

   selected:{observeMapPane.isLegendPositionBottom()};

-  enabled:{observeMapPane.isLegendPositionTop()}

+  enabled:{observeMapPane.isShowLegend() && observeMapPane.isLegendPositionTop()}

 }

+

+#addPointCount {

+  enabled:{observeMapPane.isShowLegend()};

+  selected:{observeMapPane.isAddPointCount()};

+}
+package fr.ird.observe.client.datasource.editor.api.content.data.map.actions;

+

+/*-

+ * #%L

+ * ObServe Client :: DataSource :: Editor :: API

+ * %%

+ * Copyright (C) 2008 - 2023 IRD, Ultreia.io

+ * %%

+ * This program is free software: you can redistribute it and/or modify

+ * it under the terms of the GNU General Public License as

+ * published by the Free Software Foundation, either version 3 of the

+ * License, or (at your option) any later version.

+ *

+ * This program is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+ * GNU General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public

+ * License along with this program.  If not, see

+ * <http://www.gnu.org/licenses/gpl-3.0.html>.

+ * #L%

+ */

+

+import fr.ird.observe.client.datasource.editor.api.ObserveKeyStrokesEditorApi;

+import fr.ird.observe.client.datasource.editor.api.content.data.map.ObserveMapPane;

+import fr.ird.observe.client.datasource.editor.api.content.data.map.TripMapUI;

+

+import java.awt.event.ActionEvent;

+

+import static io.ultreia.java4all.i18n.I18n.t;

+

+/**

+ * Created at 22/11/2023.

+ *

+ * @author Tony Chemit - dev@tchemit.fr

+ * @since 9.3.0

+ */

+public class AddPointCount extends TripMapUIActionSupport implements ConfigureMapAction {

+

+    public AddPointCount() {

+        super(t("observe.ui.datasource.editor.content.map.addPointCount"),

+              t("observe.ui.datasource.editor.content.map.addPointCount"),

+              null, ObserveKeyStrokesEditorApi.KEY_STROKE_SHOW_POINT_COUNT);

+    }

+

+    @Override

+    protected void doActionPerformed(ActionEvent e, TripMapUI ui) {

+        ObserveMapPane observeMapPane = ui.getObserveMapPane();

+        boolean newValue = !observeMapPane.isAddPointCount();

+        observeMapPane.setAddPointCount(newValue);

+        ui.getHandler().updateMap(observeMapPane.isShowLegend());

+    }

+}
                 TripMapPointType.psActivityObsWithFreeSchoolType,

                 TripMapPointType.psActivityObsWithObjectSchoolType,

                 TripMapPointType.psActivityLogbook,

+                TripMapPointType.psActivityLogbookWithSampling,

                 TripMapPointType.psActivityLogbookInHarbour,

                 TripMapPointType.psActivityLogbookWithFreeSchoolType,

+                TripMapPointType.psActivityLogbookWithFreeSchoolTypeWithSampling,

                 TripMapPointType.psActivityLogbookWithObjectSchoolType,

+                TripMapPointType.psActivityLogbookWithObjectSchoolTypeWithSampling,

                 TripMapPointType.psTransmittingBuoyLostLogbook

         )), createLineBuilder(true));

     }

         result.add("mapPsStyleLogbookTextSize");

         result.add("mapPsStyleLogbookLineColor");

         result.add("mapPsStyleLogbookPointColor");

+        result.add("mapPsStyleLogbookWithSamplingPointColor");

         result.add("mapPsStyleLogbookTransmittingBuoyLostPointColor");

         return result;

     }

         </Rule>

       </FeatureTypeStyle>

+      <FeatureTypeStyle>

+        <Rule>

+          <Name>Other (with sampling)</Name>

+          <ogc:Filter>

+            <ogc:PropertyIsEqualTo>

+              <ogc:PropertyName>pointType</ogc:PropertyName>

+              <ogc:Literal>psActivityLogbookWithSampling</ogc:Literal>

+            </ogc:PropertyIsEqualTo>

+          </ogc:Filter>

+          <PointSymbolizer>

+            <Graphic>

+              <Mark>

+                <WellKnownName>ttf://Serif#U+2299</WellKnownName>

+                <Fill>

+                  <CssParameter name="fill">${mapPsStyleLogbookWithSamplingPointColor}</CssParameter>

+                </Fill>

+                <Stroke>

+                  <CssParameter name="stroke">#000000</CssParameter>

+                  <CssParameter name="stroke-width">1</CssParameter>

+                </Stroke>

+              </Mark>

+              <Size>16</Size>

+            </Graphic>

+          </PointSymbolizer>

+        </Rule>

+      </FeatureTypeStyle>

+

       <FeatureTypeStyle>

         <Rule>

           <Name>With free school type</Name>

         </Rule>

       </FeatureTypeStyle>

+      <FeatureTypeStyle>

+        <Rule>

+          <Name>With free school type (with sampling)</Name>

+          <ogc:Filter>

+            <ogc:PropertyIsEqualTo>

+              <ogc:PropertyName>pointType</ogc:PropertyName>

+              <ogc:Literal>psActivityLogbookWithFreeSchoolTypeWithSampling</ogc:Literal>

+            </ogc:PropertyIsEqualTo>

+          </ogc:Filter>

+          <PointSymbolizer>

+            <Graphic>

+              <Mark>

+                <WellKnownName>ttf://Serif#U+25C8</WellKnownName>

+                <Fill>

+                  <CssParameter name="fill">${mapPsStyleLogbookWithSamplingPointColor}</CssParameter>

+                </Fill>

+                <Stroke>

+                  <CssParameter name="stroke">#000000</CssParameter>

+                  <CssParameter name="stroke-width">1</CssParameter>

+                </Stroke>

+              </Mark>

+              <Size>16</Size>

+            </Graphic>

+          </PointSymbolizer>

+        </Rule>

+      </FeatureTypeStyle>

+

       <FeatureTypeStyle>

         <Rule>

           <Name>With object school type</Name>

                   <CssParameter name="stroke-width">1</CssParameter>

                 </Stroke>

               </Mark>

-              <Size>12</Size>

+              <Size>16</Size>

+            </Graphic>

+          </PointSymbolizer>

+        </Rule>

+      </FeatureTypeStyle>

+

+      <FeatureTypeStyle>

+        <Rule>

+          <Name>With object school type (with sampling)</Name>

+          <ogc:Filter>

+            <ogc:PropertyIsEqualTo>

+              <ogc:PropertyName>pointType</ogc:PropertyName>

+              <ogc:Literal>psActivityLogbookWithObjectSchoolTypeWithSampling</ogc:Literal>

+            </ogc:PropertyIsEqualTo>

+          </ogc:Filter>

+          <PointSymbolizer>

+            <Graphic>

+              <Mark>

+                <WellKnownName>ttf://Serif#U+2295</WellKnownName>

+                <Fill>

+                  <CssParameter name="fill">${mapPsStyleLogbookWithSamplingPointColor}</CssParameter>

+                </Fill>

+                <Stroke>

+                  <CssParameter name="stroke">#000000</CssParameter>

+                  <CssParameter name="stroke-width">1</CssParameter>

+                </Stroke>

+              </Mark>

+              <Size>16</Size>

             </Graphic>

           </PointSymbolizer>

         </Rule>

 observe.config.map.ps.style.logbook.text.color=[PS - Logbook] Color for text

 observe.config.map.ps.style.logbook.text.size=[PS - Logbook] Size for text

 observe.config.map.ps.style.logbook.transmitting.buoy.lost.point.color=[PS - Logbook] Color for transmitting buoy lost points

+observe.config.map.ps.style.logbook.withSampling.point.color=[PS - Logbook] Color for points (with sampling)

 observe.config.map.ps.style.observations.line.color=[PS - Observations] Color for lines

 observe.config.map.ps.style.observations.point.color=[PS - Observations] Color for points

 observe.config.map.ps.style.observations.text.color=[PS - Observations] Color for text

 observe.ui.datasource.editor.content.map.action.zoomMoins.tip=Zoom out

 observe.ui.datasource.editor.content.map.action.zoomPlus=Zoom in

 observe.ui.datasource.editor.content.map.action.zoomPlus.tip=Zoom in

+observe.ui.datasource.editor.content.map.addPointCount=Display point counts in legend

 observe.ui.datasource.editor.content.map.east=East

 observe.ui.datasource.editor.content.map.export.chooseFile.ok=Exporter

 observe.ui.datasource.editor.content.map.export.chooseFile.png=PNG image

 observe.ui.datasource.editor.content.map.legend.logbook.setting=Logbook - Setting

 observe.ui.datasource.editor.content.map.legend.logbook.trip=Logbook - Route

 observe.ui.datasource.editor.content.map.legend.logbook.tripSegment=Logbook - Segment

-observe.ui.datasource.editor.content.map.legend.not.valid.count=( %d points are not displayed )

+observe.ui.datasource.editor.content.map.legend.not.valid.count=( %d point are not displayed )

+observe.ui.datasource.editor.content.map.legend.not.valid.counts=( %d points are not displayed )

 observe.ui.datasource.editor.content.map.legend.obs.hauling=Observation - Hauling

 observe.ui.datasource.editor.content.map.legend.obs.setting=Observation - Setting

 observe.ui.datasource.editor.content.map.legend.obs.trip=Observation - Route

 observe.ui.datasource.editor.content.map.legend.obs.tripBetweenTwoDays=Night trip

 observe.ui.datasource.editor.content.map.legend.obs.tripDay=Observation - Day trip

 observe.ui.datasource.editor.content.map.legend.tip=To display or hide legend

+observe.ui.datasource.editor.content.map.legend.valid.count=- %d point is displayed

+observe.ui.datasource.editor.content.map.legend.valid.counts=- %d point(s) are displayed

 observe.ui.datasource.editor.content.map.legendBottom=Display legend at bottom

 observe.ui.datasource.editor.content.map.legendBottom.tip=Display legend at bottom

 observe.ui.datasource.editor.content.map.legendTop=Display legend at top

 observe.config.map.ps.style.logbook.text.color=[PS - Logbook] Color for text

 observe.config.map.ps.style.logbook.text.size=[PS - Logbook] Size for text

 observe.config.map.ps.style.logbook.transmitting.buoy.lost.point.color=[PS - Logbook] Color for transmitting buoy lost points

+observe.config.map.ps.style.logbook.withSampling.point.color=[PS - Logbook] Color for points (with sampling) \#TODO

 observe.config.map.ps.style.observations.line.color=[PS - Observations] Color for lines

 observe.config.map.ps.style.observations.point.color=[PS - Observations] Color for points

 observe.config.map.ps.style.observations.text.color=[PS - Observations] Color for text

 observe.ui.datasource.editor.content.map.action.zoomMoins.tip=Zoom out \#TODO

 observe.ui.datasource.editor.content.map.action.zoomPlus=Zoom in \#TODO

 observe.ui.datasource.editor.content.map.action.zoomPlus.tip=Zoom in \#TODO

+observe.ui.datasource.editor.content.map.addPointCount=Display point counts in legend \#TODO

 observe.ui.datasource.editor.content.map.east=Este

 observe.ui.datasource.editor.content.map.export.chooseFile.ok=Exportar

 observe.ui.datasource.editor.content.map.export.chooseFile.png=imagen PNG

 observe.ui.datasource.editor.content.map.legend.logbook.setting=Logbook - Calada

 observe.ui.datasource.editor.content.map.legend.logbook.trip=Logbook - Trayecto

 observe.ui.datasource.editor.content.map.legend.logbook.tripSegment=Logbook - Trayecto

-observe.ui.datasource.editor.content.map.legend.not.valid.count=( %d points are not displayed )

+observe.ui.datasource.editor.content.map.legend.not.valid.count=( %d point is not displayed )

+observe.ui.datasource.editor.content.map.legend.not.valid.counts=( %d points are not displayed )

 observe.ui.datasource.editor.content.map.legend.obs.hauling=Observation - Arrastre

 observe.ui.datasource.editor.content.map.legend.obs.setting=Observation - Calada

 observe.ui.datasource.editor.content.map.legend.obs.trip=Observation - Route

 observe.ui.datasource.editor.content.map.legend.obs.tripBetweenTwoDays=Observation - Trayecto del noche

 observe.ui.datasource.editor.content.map.legend.obs.tripDay=Observation - Trayecto

 observe.ui.datasource.editor.content.map.legend.tip=To display or hide legend \#TODO

+observe.ui.datasource.editor.content.map.legend.valid.count=- %d point is displayed \#TODO

+observe.ui.datasource.editor.content.map.legend.valid.counts=- %d points are displayed \#TODO

 observe.ui.datasource.editor.content.map.legendBottom=Display legend at bottom

 observe.ui.datasource.editor.content.map.legendBottom.tip=Display legend at bottom

 observe.ui.datasource.editor.content.map.legendTop=Display legend at top

 observe.config.map.ps.style.logbook.text.color=[Senne - Livre de bord] Couleur pour les textes

 observe.config.map.ps.style.logbook.text.size=[Senne - Livre de bord] Taille pour les textes

 observe.config.map.ps.style.logbook.transmitting.buoy.lost.point.color=[Senne - Observations] Couleur pour la fin de transmission de balise

+observe.config.map.ps.style.logbook.withSampling.point.color=[Senne - Livre de bord] Couleur pour les points (avec échantillonnage)

 observe.config.map.ps.style.observations.line.color=[Senne - Observations] Couleur pour les traces

 observe.config.map.ps.style.observations.point.color=[Senne - Observations] Couleur pour les points

 observe.config.map.ps.style.observations.text.color=[Senne - Observations] Couleur pour les textes

 observe.ui.datasource.editor.content.map.action.zoomMoins.tip=Réduire

 observe.ui.datasource.editor.content.map.action.zoomPlus=Agrandir

 observe.ui.datasource.editor.content.map.action.zoomPlus.tip=Agrandir

+observe.ui.datasource.editor.content.map.addPointCount=Afficher le nombre de points dans la légende

 observe.ui.datasource.editor.content.map.east=Est

 observe.ui.datasource.editor.content.map.export.chooseFile.ok=Exporter

 observe.ui.datasource.editor.content.map.export.chooseFile.png=image PNG

 observe.ui.datasource.editor.content.map.legend.logbook.setting=Livre de bord - Filage

 observe.ui.datasource.editor.content.map.legend.logbook.trip=Livre de bord - Trajet

 observe.ui.datasource.editor.content.map.legend.logbook.tripSegment=Livre de bord - Trajet

-observe.ui.datasource.editor.content.map.legend.not.valid.count=( dont %d points non affichés )

+observe.ui.datasource.editor.content.map.legend.not.valid.count=( dont un point non affiché )

+observe.ui.datasource.editor.content.map.legend.not.valid.counts=( dont %d points non affichés )

 observe.ui.datasource.editor.content.map.legend.obs.hauling=Observation - Virage

 observe.ui.datasource.editor.content.map.legend.obs.setting=Observation - Filage

 observe.ui.datasource.editor.content.map.legend.obs.trip=Observation - Trajet

 observe.ui.datasource.editor.content.map.legend.obs.tripBetweenTwoDays=Observation - Trajet de nuit

 observe.ui.datasource.editor.content.map.legend.obs.tripDay=Observation - Trajet de jour

 observe.ui.datasource.editor.content.map.legend.tip=Pour afficher ou masquer la légende

-observe.ui.datasource.editor.content.map.legendBottom=Afficher la légende en haut

-observe.ui.datasource.editor.content.map.legendBottom.tip=Afficher la légende en haut

-observe.ui.datasource.editor.content.map.legendTop=Afficher la légende en bas

-observe.ui.datasource.editor.content.map.legendTop.tip=Afficher la légende en bas

+observe.ui.datasource.editor.content.map.legend.valid.count=- un point affiché

+observe.ui.datasource.editor.content.map.legend.valid.counts=- %d points affichés

+observe.ui.datasource.editor.content.map.legendBottom=Afficher la légende en bas

+observe.ui.datasource.editor.content.map.legendBottom.tip=Afficher la légende en bas

+observe.ui.datasource.editor.content.map.legendTop=Afficher la légende en haut

+observe.ui.datasource.editor.content.map.legendTop.tip=Afficher la légende en hat

 observe.ui.datasource.editor.content.map.logbook.points.not.valid=Livre de bord - Nombre de points non affichés \: %d

 observe.ui.datasource.editor.content.map.miles=milles

 observe.ui.datasource.editor.content.map.north=Nord

 observe.constant.TripMapPointType.psActivityLogbook

 observe.constant.TripMapPointType.psActivityLogbookInHarbour

 observe.constant.TripMapPointType.psActivityLogbookWithFreeSchoolType

+observe.constant.TripMapPointType.psActivityLogbookWithFreeSchoolTypeWithSampling

 observe.constant.TripMapPointType.psActivityLogbookWithObjectSchoolType

+observe.constant.TripMapPointType.psActivityLogbookWithObjectSchoolTypeWithSampling

+observe.constant.TripMapPointType.psActivityLogbookWithSampling

 observe.constant.TripMapPointType.psActivityObs

 observe.constant.TripMapPointType.psActivityObsInHarbour

 observe.constant.TripMapPointType.psActivityObsWithFreeSchoolType

     psActivityObsWithObjectSchoolType,

     psActivityLogbook,

+    psActivityLogbookWithSampling,

     psActivityLogbookInHarbour,

     psActivityLogbookWithFreeSchoolType,

+    psActivityLogbookWithFreeSchoolTypeWithSampling,

     psActivityLogbookWithObjectSchoolType,

+    psActivityLogbookWithObjectSchoolTypeWithSampling,

     psTransmittingBuoyLostLogbook,

     llTripDepartureHarbour,

                           /* 03 */ " a.latitude," +

                           /* 04 */ " a.longitude," +

                           /* 05 */ " a.vesselActivity," +

-                          /* 06 */ " a.schoolType" +

+                          /* 06 */ " a.schoolType," +

+                          /* 07 */ " (SELECT count(*) FROM ps_logbook.sampleActivity sa WHERE sa.activity = a.topiaId)" +

                           " FROM ps_logbook.route r" +

                           " INNER JOIN ps_logbook.activity a ON a.route = r.topiaId" +

                           " WHERE r.trip = ?" +

             String schoolType = resultSet.getString(6);

             String vesselActivityId = resultSet.getString(5);

             TripMapPointType type = TripMapPointType.psActivityLogbook;

+            boolean withSample = resultSet.getInt(7) > 0;

+            if (withSample) {

+                type = TripMapPointType.psActivityLogbookWithSampling;

+            }

             if (ProtectedIdsPs.PS_COMMON_ACTIVITY_HARBOUR_ID.equals(vesselActivityId)) {

                 type = TripMapPointType.psActivityLogbookInHarbour;

             } else if (schoolType != null) {

                 switch (schoolType) {

                     case ProtectedIdsPs.PS_COMMON_SCHOOL_TYPE_FREE_ID:

                         type = TripMapPointType.psActivityLogbookWithFreeSchoolType;

+                        if (withSample) {

+                            type = TripMapPointType.psActivityLogbookWithFreeSchoolTypeWithSampling;

+                        }

                         break;

                     case ProtectedIdsPs.PS_COMMON_SCHOOL_TYPE_OBJECT_ID:

                         type = TripMapPointType.psActivityLogbookWithObjectSchoolType;

+                        if (withSample) {

+                            type = TripMapPointType.psActivityLogbookWithObjectSchoolTypeWithSampling;

+                        }

                         break;

                 }

             }

 observe.constant.TripMapPointType.psActivityLogbook=Logbook - Other activity

 observe.constant.TripMapPointType.psActivityLogbookInHarbour=Logbook - In port

 observe.constant.TripMapPointType.psActivityLogbookWithFreeSchoolType=Logbook - Free School type

+observe.constant.TripMapPointType.psActivityLogbookWithFreeSchoolTypeWithSampling=Logbook - Free School type (with sampling)

 observe.constant.TripMapPointType.psActivityLogbookWithObjectSchoolType=Logbook - Object School type

+observe.constant.TripMapPointType.psActivityLogbookWithObjectSchoolTypeWithSampling=Logbook - Object School type (with sampling)

+observe.constant.TripMapPointType.psActivityLogbookWithSampling=Logbook - Other activity (with sampling)

 observe.constant.TripMapPointType.psActivityObs=Observation - Other activity

 observe.constant.TripMapPointType.psActivityObsInHarbour=Observation - In port

 observe.constant.TripMapPointType.psActivityObsWithFreeSchoolType=Observation - Free School type

 observe.constant.TripMapPointType.psActivityLogbook=Logbook - Otro Actividad

 observe.constant.TripMapPointType.psActivityLogbookInHarbour=Logbook - En puerto

 observe.constant.TripMapPointType.psActivityLogbookWithFreeSchoolType=Logbook - Banco libre

+observe.constant.TripMapPointType.psActivityLogbookWithFreeSchoolTypeWithSampling=Logbook - Banco libre (with sampling) \#TODO

 observe.constant.TripMapPointType.psActivityLogbookWithObjectSchoolType=Logbook - Banco a objeto

+observe.constant.TripMapPointType.psActivityLogbookWithObjectSchoolTypeWithSampling=Logbook - Banco a objeto (with sampling) \#TODO

+observe.constant.TripMapPointType.psActivityLogbookWithSampling=Logbook - Otro Actividad (with sampling) \#TODO

 observe.constant.TripMapPointType.psActivityObs=Observation - Otro Actividad

 observe.constant.TripMapPointType.psActivityObsInHarbour=Observation - En puerto

 observe.constant.TripMapPointType.psActivityObsWithFreeSchoolType=Observation - Banco libre

 observe.constant.TripMapPointType.llActivityObsWithSettingStart=Observation - Début de filage

 observe.constant.TripMapPointType.llTripDepartureHarbour=Port de départ

 observe.constant.TripMapPointType.llTripLandingHarbour=Port d'arrivée

-observe.constant.TripMapPointType.psActivityLogbook=Livre de Bord - Autre activité

-observe.constant.TripMapPointType.psActivityLogbookInHarbour=Livre de Bord - Au port

-observe.constant.TripMapPointType.psActivityLogbookWithFreeSchoolType=Livre de Bord - Banc libre

-observe.constant.TripMapPointType.psActivityLogbookWithObjectSchoolType=Livre de Bord - Banc objet

+observe.constant.TripMapPointType.psActivityLogbook=Livre de bord - Autre activité

+observe.constant.TripMapPointType.psActivityLogbookInHarbour=Livre de bord - Au port

+observe.constant.TripMapPointType.psActivityLogbookWithFreeSchoolType=Livre de bord - Banc libre

+observe.constant.TripMapPointType.psActivityLogbookWithFreeSchoolTypeWithSampling=Livre de bord - Banc libre (avec échantillonnage)

+observe.constant.TripMapPointType.psActivityLogbookWithObjectSchoolType=Livre de bord - Banc objet

+observe.constant.TripMapPointType.psActivityLogbookWithObjectSchoolTypeWithSampling=Livre de bord - Banc objet (avec échantillonnage)

+observe.constant.TripMapPointType.psActivityLogbookWithSampling=Livre de bord - Autre activité (avec échantillonnage)

 observe.constant.TripMapPointType.psActivityObs=Observation - Autre activité

 observe.constant.TripMapPointType.psActivityObsInHarbour=Observation - Au port

 observe.constant.TripMapPointType.psActivityObsWithFreeSchoolType=Observation - Banc libre

Tony CHEMIT pushed to branch develop at ultreiaio / ird-observe

Commits:

29 changed files:

Changes: