feat (display): RTTank-based Progress Bar backend — scale, alarm limits, and stacking support (opt-in via preference)

app/display/convert-edm/src/main/java/org/csstudio/display/converter/edm/widgets/Convert_activeBarClass.java

@@ -28,7 +28,23 @@ public Convert_activeBarClass(final EdmConverter converter, final Widget parent,
         convertColor(r.getBgColor(), widget.propBackgroundColor());
         widget.propHorizontal().setValue(!"vertical".equals(r.getOrientation()));
         widget.propPVName().setValue(convertPVName(r.getIndicatorPv()));
+
+        // Scale and range
+        widget.propScaleVisible().setValue(r.isShowScale());
         widget.propLimitsFromPV().setValue(r.isLimitsFromDb());
+        if (!r.isLimitsFromDb() && r.getMax() > r.getMin())
+        {
+            widget.propMinimum().setValue(r.getMin());
+            widget.propMaximum().setValue(r.getMax());
+        }
+
+        // Precision: 0 in EDM usually means "not set" — only override when positive.
+        if (r.getPrecision() > 0)
+            widget.propPrecision().setValue(r.getPrecision());
+
+        // EDM 'border' is a boolean; map it to a 1 px border when set.
+        if (r.isBorder())
+            widget.propBorderWidth().setValue(1);
     }
 
     @Override

app/display/editor/src/main/java/org/csstudio/display/builder/editor/properties/PropertyPanelSection.java

@@ -59,6 +59,8 @@
 import org.csstudio.display.builder.model.properties.RulesWidgetProperty;
 import org.csstudio.display.builder.model.properties.ScriptsWidgetProperty;
 import org.csstudio.display.builder.model.properties.WidgetClassProperty;
+import org.csstudio.display.builder.model.widgets.ProgressBarWidget;
+import org.csstudio.display.builder.representation.Preferences;
 import org.csstudio.display.builder.representation.javafx.FilenameSupport;
 import org.phoebus.ui.color.NamedWidgetColor;
 import org.phoebus.ui.color.WidgetColor;
@@ -163,6 +165,14 @@ void fill(final UndoableActionManager undo,
             if (property instanceof WidgetClassProperty && class_mode)
                 continue;
 
+            // When using the legacy JFX ProgressBar rendering, hide properties that
+            // only affect the RTTank-based scale rendering — they have no effect and
+            // would only confuse operators.
+            if (!Preferences.progressbar_scale_mode
+                    && property.getWidget() instanceof ProgressBarWidget
+                    && ProgressBarWidget.SCALE_MODE_PROPS.contains(property.getName()))
+                continue;
+
             // Start of new category that needs to be shown?
             if (property.getCategory() != category) {
                 category = property.getCategory();

app/display/model/src/main/java/org/csstudio/display/builder/model/Messages.java

@@ -185,6 +185,7 @@
                          WidgetProperties_BorderAlarmSensitive,
                          WidgetProperties_BorderColor,
                          WidgetProperties_BorderWidth,
+                         WidgetProperties_InnerPadding,
                          WidgetProperties_CellColors,
                          WidgetProperties_Class,
                          WidgetProperties_ColorHiHi,
@@ -326,6 +327,7 @@
                          WidgetProperties_ShowLoLo,
                          WidgetProperties_ShowMinorTicks,
                          WidgetProperties_PerpendicularTickLabels,
+                         WidgetProperties_ShowScaleLabels,
                          WidgetProperties_ShowOK,
                          WidgetProperties_ShowScale,
                          WidgetProperties_ShowUnits,

app/display/model/src/main/java/org/csstudio/display/builder/model/widgets/ProgressBarWidget.java

@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2015-2022 Oak Ridge National Laboratory.
+ * Copyright (c) 2015-2026 Oak Ridge National Laboratory.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -9,37 +9,86 @@
 
 import static org.csstudio.display.builder.model.properties.CommonWidgetProperties.propBackgroundColor;
 import static org.csstudio.display.builder.model.properties.CommonWidgetProperties.propFillColor;
+import static org.csstudio.display.builder.model.properties.CommonWidgetProperties.propFont;
 import static org.csstudio.display.builder.model.properties.CommonWidgetProperties.propHorizontal;
-import static org.csstudio.display.builder.model.properties.CommonWidgetProperties.propLimitsFromPV;
-import static org.csstudio.display.builder.model.properties.CommonWidgetProperties.propMaximum;
-import static org.csstudio.display.builder.model.properties.CommonWidgetProperties.propMinimum;
 import static org.csstudio.display.builder.model.widgets.plots.PlotWidgetProperties.propLogscale;
+import static org.csstudio.display.builder.model.properties.CommonWidgetProperties.newIntegerPropertyDescriptor;
 
 import java.util.Arrays;
 import java.util.List;
+import java.util.Set;
 
+import org.csstudio.display.builder.model.Messages;
 import org.csstudio.display.builder.model.Version;
 import org.csstudio.display.builder.model.Widget;
 import org.csstudio.display.builder.model.WidgetCategory;
 import org.csstudio.display.builder.model.WidgetConfigurator;
 import org.csstudio.display.builder.model.WidgetDescriptor;
 import org.csstudio.display.builder.model.WidgetProperty;
+import org.csstudio.display.builder.model.WidgetPropertyCategory;
+import org.csstudio.display.builder.model.WidgetPropertyDescriptor;
 import org.csstudio.display.builder.model.persist.ModelReader;
+import org.csstudio.display.builder.model.persist.NamedWidgetFonts;
+import org.csstudio.display.builder.model.persist.WidgetFontService;
 import org.csstudio.display.builder.model.persist.XMLTags;
 import org.csstudio.display.builder.model.properties.CommonWidgetProperties;
 import org.csstudio.display.builder.model.properties.HorizontalAlignment;
+import org.csstudio.display.builder.model.properties.WidgetFont;
 import org.phoebus.ui.color.WidgetColor;
 import org.phoebus.framework.persistence.XMLUtil;
 import org.w3c.dom.Document;
 import org.w3c.dom.Element;
 
-/** Widget that displays a progress bar
+/** Widget that displays a progress bar with an optional numeric scale.
+ *
+ *  <p>Extends {@link ScaledPVWidget} to inherit common scale/limit properties
+ *  (min/max range, format, precision, alarm limit lines).  The bar uses the
+ *  same rendering engine as {@link TankWidget} ({@code RTTank}) so the scale
+ *  and alarm-limit features are identical.
+ *
+ *  <p>Existing {@code .bob} files load unchanged: {@code fill_color},
+ *  {@code background_color}, {@code horizontal}, {@code limits_from_pv},
+ *  {@code minimum}, {@code maximum} and {@code log_scale} keep the same
+ *  XML names.  New properties ({@code format}, {@code precision},
+ *  {@code scale_visible}, {@code show_minor_ticks}, {@code show_scale_labels},
+ *  {@code inner_padding}, alarm limit properties)
+ *  are silently ignored by older Phoebus versions.
+ *
  *  @author Kay Kasemir
  *  @author Amanda Carpenter
+ *  @author Heredie Delvalle &mdash; CLS, ScaledPVWidget refactoring, scale support
  */
 @SuppressWarnings("nls")
-public class ProgressBarWidget extends PVWidget
+public class ProgressBarWidget extends ScaledPVWidget
 {
+    /** Property names that only take effect when the RTTank-based rendering engine is
+     *  active ({@code progressbar_scale_mode=true}).  The property editor uses this set
+     *  to hide irrelevant entries when the legacy JFX ProgressBar rendering is selected,
+     *  keeping the panel uncluttered for operators who do not need scale features.
+     *
+     *  <p>Properties used by <em>both</em> renderers are intentionally absent, including
+     *  {@code minimum}, {@code maximum}, {@code limits_from_pv}, {@code horizontal},
+     *  {@code log_scale}, {@code fill_color}, {@code background_color},
+     *  {@code border_width} (drawn as a CSS outer border by {@code RegionBaseRepresentation}
+     *  in the legacy renderer; as an inner canvas border in RTTank mode), and
+     *  {@code border_alarm_sensitive} (alarm-sensitive outer border, also handled by
+     *  {@code RegionBaseRepresentation} for all widget types). */
+    public static final Set<String> SCALE_MODE_PROPS = Set.of(
+        "format", "precision",
+        "scale_visible", "show_minor_ticks", "show_scale_labels",
+        "opposite_scale_visible", "perpendicular_tick_labels", "font",
+        "inner_padding",
+        "alarm_limits_from_pv", "show_alarm_limits",
+        "level_lolo", "level_low", "level_high", "level_hihi",
+        "minor_alarm_color", "major_alarm_color");
+
+    /** 'inner_padding' — extra inset from widget edge to the fill bar, in pixels (0..20).
+     *  Defaults to 3, matching the CSS inset of the stock JFX ProgressBar.
+     *  Set to 0 for a tight, edge-to-edge bar with no surrounding gap. */
+    public static final WidgetPropertyDescriptor<Integer> propInnerPadding =
+        newIntegerPropertyDescriptor(WidgetPropertyCategory.DISPLAY, "inner_padding",
+                                     Messages.WidgetProperties_InnerPadding, 0, 20);
+
     /** Widget descriptor */
     public static final WidgetDescriptor WIDGET_DESCRIPTOR =
         new WidgetDescriptor("progressbar", WidgetCategory.MONITOR,
@@ -55,7 +104,7 @@
         }
     };
 
-    /** Widget configurator to read legacy *.opi files*/
+    /** Widget configurator to read legacy *.opi files */
     private static class ProgressBarConfigurator extends WidgetConfigurator
     {
         public ProgressBarConfigurator(final Version xml_version)
@@ -72,24 +121,31 @@
             if (xml_version.getMajor() < 2)
             {
                 final ProgressBarWidget bar = (ProgressBarWidget) widget;
-                // BOY progress bar reserved room on top for limit markers,
-                // and on bottom for scale
+                // BOY reserved room on top for limit markers and on the bottom for
+                // a scale. This widget now actually has a scale, so only adjust for
+                // the marker area that has been removed.
                 if (XMLUtil.getChildBoolean(xml, "show_markers").orElse(true))
                 {
-                    // This widget has no markers on top, so move widget down and reduce height.
-                    // There is no 'marker font', seems to have constant height
                     final int reduce = 25;
                     bar.propY().setValue(bar.propY().getValue() + reduce);
                     bar.propHeight().setValue(bar.propHeight().getValue() - reduce);
                 }
-                // Do use space below where BOY placed markers for the bar itself.
-                // In the future, there could be a scale.
 
                 final Element el = XMLUtil.getChildElement(xml, "color_fillbackground");
                 if (el != null)
                     bar.propBackgroundColor().readFromXML(model_reader, el);
 
-                // Create text update for the value indicator
+                // BOY's 'show_scale' boolean maps to our 'scale_visible' property.
+                final Element showScaleEl = XMLUtil.getChildElement(xml, "show_scale");
+                if (showScaleEl != null)
+                    bar.propScaleVisible().readFromXML(model_reader, showScaleEl);
+
+                // BOY's 'scale_font' maps to our 'font' property.
+                final Element scaleFontEl = XMLUtil.getChildElement(xml, "scale_font");
+                if (scaleFontEl != null)
+                    bar.propFont().readFromXML(model_reader, scaleFontEl);
+
+                // Create a companion TextUpdate widget for the BOY value label.
                 if (XMLUtil.getChildBoolean(xml, "show_label").orElse(true))
                 {
                     final Document doc = xml.getOwnerDocument();
@@ -125,31 +181,47 @@
         return new ProgressBarConfigurator(persisted_version);
     }
 
-    private volatile WidgetProperty<Boolean> limits_from_pv;
-    private volatile WidgetProperty<Double> minimum;
-    private volatile WidgetProperty<Double> maximum;
-    private volatile WidgetProperty<Boolean> log_scale;
+    private volatile WidgetProperty<WidgetFont> font;
     private volatile WidgetProperty<WidgetColor> fill_color;
     private volatile WidgetProperty<WidgetColor> background_color;
-    private volatile WidgetProperty<Boolean> horizontal;
+    private volatile WidgetProperty<Boolean>     log_scale;
+    private volatile WidgetProperty<Boolean>     horizontal;
+    private volatile WidgetProperty<Boolean>     scale_visible;
+    private volatile WidgetProperty<Boolean>     show_minor_ticks;
+    private volatile WidgetProperty<Boolean>     show_scale_labels;
+    private volatile WidgetProperty<Boolean>     opposite_scale_visible;
+    private volatile WidgetProperty<Boolean>     perpendicular_tick_labels;
+    private volatile WidgetProperty<Integer>     border_width_prop;
+    private volatile WidgetProperty<Integer>     inner_padding_prop;
 
     /** Constructor */
     public ProgressBarWidget()
     {
-        super(WIDGET_DESCRIPTOR.getType());
+        super(WIDGET_DESCRIPTOR.getType(), 300, 30);
     }
 
     @Override
     protected void defineProperties(final List<WidgetProperty<?>> properties)
     {
         super.defineProperties(properties);
-        properties.add(fill_color = propFillColor.createProperty(this, new WidgetColor(60, 255, 60)));
+        properties.add(font            = propFont.createProperty(this, WidgetFontService.get(NamedWidgetFonts.DEFAULT)));
+        properties.add(fill_color      = propFillColor.createProperty(this, new WidgetColor(60, 255, 60)));
         properties.add(background_color = propBackgroundColor.createProperty(this, new WidgetColor(250, 250, 250)));
-        properties.add(limits_from_pv = propLimitsFromPV.createProperty(this, true));
-        properties.add(minimum = propMinimum.createProperty(this, 0.0));
-        properties.add(maximum = propMaximum.createProperty(this, 100.0));
-        properties.add(log_scale = propLogscale.createProperty(this, false));
-        properties.add(horizontal = propHorizontal.createProperty(this, true));
+        properties.add(log_scale       = propLogscale.createProperty(this, false));
+        properties.add(horizontal      = propHorizontal.createProperty(this, true));
+        properties.add(scale_visible          = propScaleVisible.createProperty(this, false));
+        properties.add(show_minor_ticks        = propShowMinorTicks.createProperty(this, true));
+        properties.add(show_scale_labels       = propShowScaleLabels.createProperty(this, true));
+        properties.add(opposite_scale_visible  = propOppositeScaleVisible.createProperty(this, false));
+        properties.add(perpendicular_tick_labels = propPerpendicularTickLabels.createProperty(this, false));
+        properties.add(border_width_prop         = propBorderWidth.createProperty(this, 0));
+        properties.add(inner_padding_prop        = propInnerPadding.createProperty(this, 3));
+    }
+
+    /** @return 'font' property */
+    public WidgetProperty<WidgetFont> propFont()
+    {
+        return font;
     }
 
     /** @return 'fill_color' property */
@@ -164,33 +236,57 @@
         return background_color;
     }
 
-    /** @return 'limits_from_pv' property */
-    public WidgetProperty<Boolean> propLimitsFromPV()
+    /** @return 'log_scale' property */
+    public WidgetProperty<Boolean> propLogScale()
     {
-        return limits_from_pv;
+        return log_scale;
     }
 
-    /** @return 'minimum' property */
-    public WidgetProperty<Double> propMinimum()
+    /** @return 'horizontal' property */
+    public WidgetProperty<Boolean> propHorizontal()
     {
-        return minimum;
+        return horizontal;
     }
 
-    /** @return 'maximum' property */
-    public WidgetProperty<Double> propMaximum()
+    /** @return 'scale_visible' property */
+    public WidgetProperty<Boolean> propScaleVisible()
     {
-        return maximum;
+        return scale_visible;
     }
 
-    /** @return 'log_scale' property */
-    public WidgetProperty<Boolean> propLogScale()
+    /** @return 'show_minor_ticks' property */
+    public WidgetProperty<Boolean> propShowMinorTicks()
     {
-        return log_scale;
+        return show_minor_ticks;
     }
 
-    /** @return 'horizontal' property */
-    public WidgetProperty<Boolean> propHorizontal()
+    /** @return 'show_scale_labels' property */
+    public WidgetProperty<Boolean> propShowScaleLabels()
     {
-        return horizontal;
+        return show_scale_labels;
+    }
+
+    /** @return 'opposite_scale_visible' property */
+    public WidgetProperty<Boolean> propOppositeScaleVisible()
+    {
+        return opposite_scale_visible;
+    }
+
+    /** @return 'perpendicular_tick_labels' property */
+    public WidgetProperty<Boolean> propPerpendicularTickLabels()
+    {
+        return perpendicular_tick_labels;
+    }
+
+    /** @return 'border_width' property (0 = no border) */
+    public WidgetProperty<Integer> propBorderWidth()
+    {
+        return border_width_prop;
+    }
+
+    /** @return 'inner_padding' property (extra inset between widget edge and fill bar, 0..20 px) */
+    public WidgetProperty<Integer> propInnerPadding()
+    {
+        return inner_padding_prop;
     }
 }