6038-20220204.02.patch

     **                           if the SCREEN-VALUE is still unknown.
     **     AL2 20220122          Allow set of unknown value to simple and drop-down modes.
     **         20220124          Moved screen-value validity check in ControlSetEntity.
     **         20220204          Extend screen-value validation to update the value same as in 4GL.
     */
     /*
     ** This program is free software: you can redistribute it and/or modify
-...
+       }
        /**
         * Set the current value in the screen buffer of the backing data for
         * this widget.  If the given value is <code>null</code> then this
         * widget will be set to the uninitialized value.
+        *
         * @param    value
         *           The new value for the widget, use <code>null</code> to set
         *           the value as uninitialized.
         */
        @Override
        protected void setScreenValueInt(character value)
+       {
           if (!internalScreenValueUsage && !value.isUnknown() && value.getValue().isEmpty())
+          {
              value = new character();
+          }
           super.setScreenValueInt(value);
+       }
        /**
         * Store array of items into config.
+        *
         * @param    items
-...
        @Override
        boolean setScreenValue(ScreenBuffer frameBuf, Object value, boolean inUIStmt)
+       {
           if (!internalScreenValueUsage || inUIStmt)
           if (!(value instanceof character))
+          {
              // it is valid to assign unknown value (?) only to character drop-down and simple combo-box
              // for default and drop-down-list combo-box, the old screen-value should be kept
              if (value == null ||
                 (value instanceof BaseDataType   &&
                 !(value instanceof character)    &&
                 ((BaseDataType) value).isUnknown()))
+             {
                 return false;
+             }
              boolean pairs = (config.pairs != null && config.pairs);
              if ((!pairs || !getScreenValue().isUnknown())      &&
                  (value instanceof character)                   &&
                  (!((character) value).isUnknown())             &&
                  ((character) value).toJavaType().length() == 0)
+             {
                 // in pair mode an empty string is not allowed if the SCREEN-VALUE is already assigned to
                 // something else, even if an empty string exists
                 // in non-pair mode, an empty string is never allowed.
                 return false;
+             }
              // we can't set non-character value to selection list
              return false;
+          }
           return super.setScreenValue(frameBuf, value, inUIStmt);
+       }
-...
        protected boolean isValidScreenValue(character value)
+       {
           ComboBoxConfig.Mode mode = getAttr("mode", () -> config.mode);
           if (mode == SIMPLE || mode == DROP_DOWN)
           if (mode == SIMPLE || mode == DROP_DOWN || value.isUnknown() || TextOps.isEmpty(value))
+          {
              // unknown is a valid screen value for a SIMPLE or DROP-DOWN combo-box widget
              // the screen value to be set shouldn't be part of the item list
              // for a SIMPLE or DROP-DOWN combo-box widget anything works
              // unknown or empty string (or only spaces) clear selection for LIST
              return true;
+          }
-...
              setScreenValueInt(new character(" "));
+          }
+       }
        /**
         * Validate the value(s) for SCREEN-VALUE attribute. If valid the passed in
         * value will be updated to reflect the resulting value.
+        *
         * - empty string will set the value to unknown, unless a valid item value.
         * - for unknown the result can be empty string if a valid item value.
         * - first item found that match the value is used (case insensitive)
+        *
         * @param value
         *        The to be validated as SCREEN-VALUE attribute.
+        *
         * @return <code>true</code> if the value is a valid screen-value.
         */
        @Override
        boolean validateScreenValue(character value)
+       {
           if (super.validateScreenValue(value))
+          {
              // if valid update the screen-value
              if (value.isUnknown())
+             {
                 // looks like when unknown it tries to find an empty item first
                 value.assign("");
+             }
              ControlSetItem[] items = getAttr("items", () -> config.items);
              for (ControlSetItem item : items)
+             {
                 // item found, update value if different case
                 if (CompareOps._isEqual(value, item.getCharacterValue()))
+                {
                    value.assign(item.getCharacterValue());
                    return true;
+                }
+             }
              // if value is empty and no matching item found reset to unknown
              if (TextOps.isEmpty(value))
+             {
                 value.setUnknown();
+             }
              return true;
+          }
           return false;
+       }
+    }

new/src/com/goldencode/p2j/ui/ControlSetEntity.java 2022-02-04 17:19:39 +0000
2857	2857	{
2858	2858	if (inUIStmt \|\| !internalScreenValueUsage)
2859	2859	{
2860		if (value instanceof character && !validateScreenValue((character) value))
	2860	if (value instanceof character)
2861	2861	{
2862		return false;
	2862	character val = new character((character) value);
	2863
	2864	if (!validateScreenValue((character) val))
	2865	{
	2866	return false;
	2867	}
	2868	// the value might have been updated by validation
	2869	return super.setScreenValue(frameBuf, val, inUIStmt);
2863	2870	}
2864	2871	}
2865	2872
...	...
2867	2874	}
2868	2875
2869	2876	/**
2870		* Validate the value(s) for SCREEN-VALUE attribute.
	2877	* Validate the value(s) for SCREEN-VALUE attribute. The value passed as
	2878	* input might be updated by specific widget validation.
2871	2879	*
2872	2880	* @param value
2873		* The to be validated as SCREEN-VALUE attribute.
	2881	* The to be validated as SCREEN-VALUE attribute.
2874	2882	*
2875	2883	* @return <code>true</code> if the value is a valid screen-value.
2876	2884	*/

     **     EVL 20210309          Fixed set screen value for several conditions when screen buffer is not updating.
     **     VVT 20220115          System-wide warningAlreadyRealized() method is now used to handle attempts to
     **                           set attribute of a realized widget. See also #5937-32.
     **     ME  20220204          Reuse/extend the screen-value validation from base class.
     */
     /*
     ** This program is free software: you can redistribute it and/or modify
-...
           return super.getScreenValue(initialized, bdt, fmt, ignoreFormat);
+       }
        /**
         * Check if the tested value is in the control-set values.
         * Unknown is not valid, empty string is ignored if not a valid value.
+        *
         * @param    value
         *           The tested value
+        *
         * @return   True if the tested value is in the control-set values, otherwise false.
         */
        @Override
        protected boolean isValidScreenValue(character value)
+       {
           return !value.isUnknown() && (TextOps.isEmpty(value) || super.isValidScreenValue(value));
+       }
        /**
         * Internal worker for setting the SCREEN-VALUE on a per-widget basis.
+        *
         * @param   frameBuf
         *          The frame buffer where to save the value.
         * @param   value
         *          The value to be set via SCREEN-VALUE attribute.
         * @param   inUIStmt
         *          Flag indicating this call originates from a UI statement.
+        *
         * @return  <code>true</code> if the caller can proceed, as the screen-value can be set.
         * Validate the value(s) for SCREEN-VALUE attribute. If valid the passed in
         * value will be updated to reflect the resulting value.
+        *
         * - empty string will set the value to unknown, unless a valid item value.
         * - for unknown the result can be empty string if a valid item value.
+        *
         * @param value
         *        The to be validated as SCREEN-VALUE attribute.
+        *
         * @return <code>true</code> if the value is a valid screen-value.
         */
        @Override
        boolean setScreenValue(ScreenBuffer frameBuf, Object value, boolean inUIStmt)
        boolean validateScreenValue(character value)
+       {
           if (frameBuf.getWidgetValue(getId()) != null)
+          {
              if (value instanceof character && "".equals(((character) value).toJavaType()))
+             {
                 return false;
+             }
+          }
           if (value instanceof BaseDataType && !isValidScreenValue(character.valueOf((BaseDataType) value)))
+          {
              // show warning if it is from "set screen-value" statements but not from UI statements
              if (!inUIStmt)
+             {
                 ErrorManager.recordOrShowError(4058, String.format(
                          "Attribute SCREEN-VALUE for the %s %s has an invalid value of %s", type(),
                          widgetName(), ((BaseDataType) value).isUnknown() ? "UNKNOWN" : value), false);
+             }
           if (super.validateScreenValue(value))
+          {
              ControlSetItem[] items = getAttr("items", () -> config.items);
              return false;
+          }
           return super.setScreenValue(frameBuf, value, inUIStmt);
+       }
        /**
         * Set the current value in the screen buffer of the backing data for this widget. If the given
         * value is <code>null</code> then this widget will be set to the uninitialized value.
+        *
         * @param    value
         *           The new value for the widget, use <code>null</code> to set the value as uninitialized.
         */
        @Override
        protected void setScreenValueInt(character value)
+       {
           if (value != null && "".equals(value.toStringMessage()))
+          {
              // return silently
              return;
+          }
           super.setScreenValueInt(value);
+       }
              for (ControlSetItem item : items)
+             {
                 // item found, update value if different case
                 if (CompareOps._isEqual(value, item.getCharacterValue()))
+                {
                    value.assign(item.getCharacterValue());
                    return true;
+                }
+             }
+          }
           return false;
+       }
        /**
         * Report missing argument for replace().
+        *

     **     EVL 20210309          Adding saving the currently selected button index.
     **     CA  20210803          If WINDOW:KEEP-FRAME-Z-ORDER is set, a DISPLAY can 'move-to-top' certain widgets.
     **     AL2 20211213          Set the current node when refreshing items list (only when not ChUI).
     **     ME  20220104          When setting screen-value select first item that match.
     */
     /*
-...
              character btnValue = new character(button.getValue());
              character charValue = new character(value);
              // first entry that matches (case insensitive)
              if (btnValue.equals(charValue))
+             {
                 selectButton(button);
                 return;
+             }
+          }
+       }

     **     CA  20210805 The entry-field for a combo-box must always be 'on top' of the combo-box.
     **     CA  20210818 Fixed setHidden, setVisible, moveToTop and moveToBottom for SIMPLE and DROP-DOWN mode.
     **     VVT 20220126 Updated after methods 'index' and 'select(int)' were renamed in DefaultList. See #5937.
     **     ME  20220204 Unknown screen-value is shown as empty string instead of question mark.
     */
     /*
-...
              if (entryField != null)
+             {
                 entryField.setValue(listValue ? new character(model().selected()) : value);
                 if (listValue)
+                {
                    entryField.setValue(new character(model().selected()));
+                }
                 else
+                {
                    // unknown is shown as empty string instead of question mark
                    entryField.setValue(value.isUnknown() ? new character("") : value);
+                }
+             }
+          }
+       }

Project

General

Profile

FWD » Core Development » User Interface