11294a_fix.patch

     **                           instead of the encoded image bytes.
     ** 195 AL2 20260818          getSelectedRowIndex() returns Integer and reports a missing browse with
     **                           null;  -1 is a valid row index after an indexed reposition.
     ** 196 HC  20260929          Removed 'moveToBatch()', no longer used. Refs #11294.
     */
     /*
-...
        public Boolean moveToTop(int id);
        /**
         * Moves the widgets to the top or bottom according to their Z-order. This method is designed to
         * efficiently reposition widgets and avoid a server–client round trip for each widget.
+        *
         * @param   top
         *          {@code true} to move the widgets to the top, {@code false} to move them to the bottom.
         * @param   ids
         *          The widget ids.
+        *
         * @return  an array of {@link Boolean} values representing the result for each widget:
         *          {@link Boolean#TRUE} if the move was successful, {@link Boolean#FALSE} if unsuccessful, or
         *          {@code null} if no widget with the given id was found.
         */
        public Boolean[] moveToBatch(boolean top, int[] ids);
        /**
         * Move the widget to the Bottom in z-order
+        *
         * @param id

     **         20260525          Skip the removeFromDeferredDefs call in destroy() for frames whose
     **                           ScreenDefinition was never enqueued via deferPush.
     ** 405 TG  20260717          Added isClientRegistered.
     ** 406 HC  20260929          setChildrenVisible no longer moves the hidden widgets to the top, the client
     **                           does it when they are realized after their frame. Refs #11294.
     */
     /*
-...
+          }
           i = 0;
           List<GenericWidget<?>> moveToTopWidgets = new ArrayList<>();
           for (GenericWidget<?> widget : widgets)
+          {
              // hidden widgets are not overridden by this
              // hidden widgets are not overridden by this; the client moves them to the top when they
              // are realized later than the frame
              if (isHidden[i++] && value)
+             {
                 if (!(widget instanceof FrameWidget))
+                {
                    moveToTopWidgets.add(widget);
+                }
                 continue;
+             }
-...
             widget.setAttr("visible", widget.config.visible, value, WidgetConfig::setVisible, widget.config);
+          }
           moveToBatchWorker(true, moveToTopWidgets);
+       }
        /**
-...
+       }
        /**
         * Moves the given widgets to the top or bottom of their frames. Updates the client with the new
         * configuration and synchronizes the state on the server.
+        *
         * @param   top
         *          {@code true} for moving to top, or {@code false} for bottom.
         * @param   widgets
         *          The widgets to be repositioned.
         */
        private void moveToBatchWorker(boolean top, List<GenericWidget<?>> widgets)
+       {
           if (widgets == null || widgets.isEmpty())
+          {
              return;
+          }
           int size = widgets.size();
           int[] ids = new int[size];
           for (int i = 0; i < size; i++)
+          {
              ids[i] = widgets.get(i).getId();
+          }
           Boolean[] results = LogicalTerminal.moveToBatch(top, ids);
           for (int i = 0; i < results.length; i++)
+          {
              widgets.get(i).syncMoveToState(top, results[i]);
+          }
+       }
        /**
         * Converts a frame element array into a array of widgets.  Any nodes that
         * are assignment only result in a <code>null</code> entry in the array.
+        *

     ** 181 CA  20260707          Ensure the browse columns are properly registered as widgets and also deleted
     **                           when the BROWSE get deleted.
     ** 182 RNC 20260629          An unknown HELP value should be passed downstream as null.
     ** 183 HC  20260929          VISIBLE = TRUE clears HIDDEN before it views the frame, so the widget is
     **                           realized together with its frame. Refs #11294.
     */
     /*
-...
                 // the direct frame is not visible, force a view on it
                 if (!frame.getFrameWidget()._isVisible())
+                {
                    if (config.hidden)
+                   {
                       // like 4GL, un-hide the widget before the frame is viewed, so an unrealized
                       // frame realizes it together with the other widgets
                       _setHidden(false);
                       pushWidgetAttr("hidden", false);
+                   }
                    frame.view();
+                }
                 else

     ** 485 TG  20260707          Ensure that the parent frame gets pushed before child frame.
     ** 486 AL2 20260818          getSelectedRowIndex() returns Integer and reports a missing browse with
     **                           null;  -1 is a valid row index after an indexed reposition.
     ** 487 HC  20260929          Removed 'moveToBatch()', no longer used. Refs #11294.
     */
     /*
-...
+       }
        /**
         * Moves the widgets to the top or bottom according to their Z-order. This method is designed to
         * efficiently reposition widgets and avoid a server–client round trip for each widget.
+        *
         * @param   top
         *          {@code true} to move the widgets to the top, {@code false} to move them to the bottom.
         * @param   ids
         *          The widget ids.
+        *
         * @return  an array of {@link Boolean} values representing the result for each widget:
         *          {@link Boolean#TRUE} if the move was successful, {@link Boolean#FALSE} if unsuccessful, or
         *          {@code null} if no widget with the given id was found.
         */
        public static Boolean[] moveToBatch(boolean top, int[] ids)
+       {
           return locate().clientCall().moveToBatch(top, ids);
+       }
        /**
         * Set the state of SESSION:IMMEDIATE-DISPLAY attribute.
+        *
         * @param   on

     ** 1100 RNC 20260713          Added the 'inactiveWindowScrolling' variable. Skip the SE_VALUE_CHANGED focus
     **                            forcing quirk for the mouse wheel originated events when inactive window
     **                            scrolling is enabled.
     ** 1111 HC  20260929          Removed 'moveToBatch()', no longer used. Refs #11294.
     */
     /*
-...
+       }
        /**
         * Moves the widgets to the top or bottom according to their Z-order. This method is designed to
         * efficiently reposition widgets and avoid a server–client round trip for each widget.
+        *
         * @param   top
         *          {@code true} to move the widgets to the top, {@code false} to move them to the bottom.
         * @param   ids
         *          The widget ids.
+        *
         * @return  an array of {@link Boolean} values representing the result for each widget:
         *          {@link Boolean#TRUE} if the move was successful, {@link Boolean#FALSE} if unsuccessful, or
         *          {@code null} if no widget with the given id was found.
         */
        public Boolean[] moveToBatch(boolean top, int[] ids)
+       {
           Boolean[] result = new Boolean[ids.length];
           for (int i = 0; i < ids.length; i++)
+          {
              result[i] = top ? moveToTop(ids[i]) : moveToBottom(ids[i]);
+          }
           return result;
+       }
        /**
         * Set the custom mouse pointer for a widget or reset to the default one
+        *
         * @param id

     ** 344 RNC 20260220          Avoid storing duplicate lambdas as remove listeners.
     ** 345 RNC 20260225          Added the 'getScrollPane()' method.
     ** 346 SB  20260706          Added 'isFramePane'.
     ** 347 HC  20260929          Widgets hidden when the frame is realized are moved to the top when they are
     **                           realized later. A child frame shown while its parent is not realized keeps
     **                           its z-order. Refs #11294.
     */
     /*
-...
        /** Saved frame pane dimension. */
        private Dimension savedPaneDim = null;
        /** Flag indicating that the frame is being realized. */
        private boolean realizing = false;
        /** Track dynamic down. */
        private boolean dynamicDown = false;
-...
           return savedState;
+       }
        /**
         * Check if the frame is being realized.
+        *
         * @return   <code>true</code> while {@link #realizeFrame(boolean)} realizes the frame.
         */
        public boolean isRealizing()
+       {
           return realizing;
+       }
        /**
         * Realize the frame, only if it's not yet realized.
+        *
-...
+             }
              config().realized = true;
              // widgets realized during the frame realization keep their original z-order
              realizing = true;
              FrameConfig config = config();
              // 4GL bug, row/column affects the parent inner size
-...
              // z-order is normalized after layout is done; layout needs to use the original widget order
              // regardless of their z-class
              this.getContentPane().normalizeZOrder();
              // widgets hidden now are realized later than the frame, so they are moved to the top of
              // their siblings when realized
              for (Widget<O> w : getContentPane().widgets())
+             {
                 if (w instanceof AbstractWidget)
+                {
                    ((AbstractWidget<O>) w).setRaiseOnRealize(w.hidden());
+                }
+             }
              realizing = false;
+          }
           // process pending tab item list
-...
+       {
           active = true;
           viewed = true;
           // a child frame shown while its parent frame is not realized is realized together with the
           // parent frame, so it keeps its original z-order
           Frame<O> parentFrame = parent(Frame.class);
           if (parentFrame != null && !parentFrame.isRealized())
+          {
              return;
+          }
           /* ENABLE and DISPLAY WITH FRAME doesn't change its z-order */
           if (currentStatement == null ||
               (currentStatement != UIStatement.ENABLE && currentStatement != UIStatement.DISPLAY &&

     **                  dragging has started.
     ** 118 RNC 20260402 Fixed javadoc warnings.
     ** 119 RNC 20260225 Overridden the 'getMouseWheelTarget()' method.
     ** 120 HC  20260929 A field-level widget realized after its frame is moved to the top of its siblings,
     **                  instead of raising it on its first visible config change. Refs #11294.
     */
     /*
-...
        /** Widget visible flag. This field is needed only for instances without config. */
        private boolean visible = true;
        /**
         * Flag indicating that this widget is moved to the top of its siblings when it is realized
         * after its frame.  The frame clears it for the widgets realized together with the frame.
         */
        private boolean raiseOnRealize = true;
        /** Storage for focus listeners. */
        private ArrayList<FocusListener> focusListeners = new ArrayList<FocusListener>();
-...
+       }
        /**
         * Set the flag indicating that this widget is moved to the top of its siblings when it is
         * realized after its frame.
+        *
         * @param    raiseOnRealize
         *           <code>true</code> to move the widget to the top when it is realized.
         */
        public void setRaiseOnRealize(boolean raiseOnRealize)
+       {
           this.raiseOnRealize = raiseOnRealize;
+       }
        /**
         * Hide widget.
         */
        @Override
-...
                 Frame container = parent(Frame.class);
                 if (container != null)
+                {
                    // a field-level widget realized after its frame goes on top of its siblings
                    if (raiseOnRealize                              &&
                        parent() == container.getContentPane()      &&
                        container.isRealized()                      &&
                        !container.isRealizing())
+                   {
                       moveToTop();
+                   }
                    container.getContentPane().normalizeZOrder();
+                }
                 widgetRealized();
-...
+          }
           // if widget was not yet realized and we change from hidden to visible ensure it is on the top
           // of paint sequence
           if (!c.realized && c.visible && c.visible != beforeUpdate.visible)
           // of paint sequence; field-level widgets are raised in _setVisible, when they are realized
           // after their frame
           if (!c.realized && c.visible && c.visible != beforeUpdate.visible && parent(Frame.class) == null)
+          {
              moveToTop();
+          }

Project

General

Profile

FWD » Core Development » User Interface