FWD » Core Development » User Interface

      this.target.setBlob(parameterIndex, inputStream); }

   public void setNClob(int parameterIndex, Reader reader) throws SQLException { 

      this.target.setNClob(parameterIndex, reader); }

}

   /**

    * Sets the BGCOLOR writable attribute.  Private internal version.

    *

    */

   private void setBgColorInt(NumberType bgColor)

   {

 * @param <N> 

 *        node type

 */

extends WidgetConfigExt

{

   /** Node id of the currently selected node */

   public boolean sorted;

   /** The flat list of tree nodes */

   /** Indentation pixel size */

   public int indentation;

   /** Flag to toggle expand on ENTER */

   public boolean expandOnEnter;

   /** Flag to toggle expand node icons visibility */

   public boolean showExpandIcon = true;

   /**

    * Create node entry instance.

    * @return node entry instance

    */

   /**

    * Create a new config and associate it with the given widget.

    *

   {

      super.applyConfig(config);

      selectedNodeId = cfg.selectedNodeId;

      textEdit = cfg.textEdit;

      dragDrop = cfg.dragDrop;

      showExpandIcon       = (booleanAttrs & ATTR_MASK_SHOW_EXPAND_ICON) == ATTR_MASK_SHOW_EXPAND_ICON;

      removeNodeOnCollapse = (booleanAttrs & ATTR_MASK_REM_NODE_COLLAPSE) == ATTR_MASK_REM_NODE_COLLAPSE;

      scrollNodeCount = in.readInt();

      draggedNode = in.readInt();

      draggedOverNode = in.readInt();

 * TreeList widget configuration.

 * @param <N> node entry type

 */

{

   /** List of column configurations, index 0 is the column showing the tree portion of the widget */

   public List<Column> columns = new ArrayList<>();

   {

      super.applyConfig(config);

      columns = cfg.columns;

      fixedColumn = cfg.fixedColumn;

      showHeader = cfg.showHeader;

   {

      super.applyConfig(config);

      fixedColumn = cfg.fixedColumn;

      showHeader = cfg.showHeader;

      triggerColumn = cfg.triggerColumn;

    * @return node entry instance

    */

   @Override

   {

   }

   /**

    */

   public TreeListNodeEntry()

   {

   }

   /**

    * @param   cellIndex

    *          Cell index.

    *

    */

   @Override

   {

      return cellIndex >= 0 && cellIndex < cellValues.size() ? cellValues.get(cellIndex) : null;

   }

 * @param <N> 

 *        node type

 */

implements TreeListNode

{

   /**

    * @param   parent

    *          Node parent.

    */

   {

      super(treeList, nodeId, key, parent);

      cellValues.add("");

    * @param   parent

    *          Node parent.

    */

                               final int nodeId,

                               final String key,

                               final String text,

   {

      super(treeList, nodeId, key, parent);

      cellStrings.add(text);

   @Override

   public character getNodeText()

   {

   }

   /**

    * @return  new instance of {@link TreeListNodeEntry}.

    */

   @Override

   {

      super.saveToEntry(entry);

      entry.cellValues.addAll(cellValues);

      entry.cellFGColors.addAll(cellFGColors);

    * @return the cell value

    */

   public final <T> T getCellValue(final int colIndex,

   {

      final List<T> values = getValues.apply(this);

      return (colIndex >= values.size()) ? null : values.get(colIndex);

      {

         case STRING:

         case ICON:

         default:

            TreeWidgetBase.LOG.severe("Node comparing: dataType not supported: " + dataType);

 * @param <N> 

 *        node type

 */

implements TreeList

{

   /** Flag marking columns or column position changes are pending */

    */

   public TreeListWidget(boolean dynamic)

   {

      clearAll();

    * @param   config

    *          The config to use to create widget.

    */

   {

      super(dynamic, config);

   }

   @Override

   public integer getSortedColumns()

   {

      for (int i = ccolumns.size() - 1; i >= 0; i--)

      {

         if(ccolumns.get(i).sort != Sorting.NONE)

   @Override

   public integer getTriggerColumn()

   {

   }

   /**

   {

      // assert colIndex == null && !colIndex.isUnknown();

      final int sortedColumn = colIndex.intValue();

      for (int i = ccolumns.size() - 1; i >= 0; i--)

      {

   @Override

   public integer getSortedColumnCount()

   {

               .filter(c -> c.sort != Sorting.NONE).count());

   }

    *          Column index. Set negative value or unknown to unfix all columns.

    */

   @Override

   {

      short newValue = -1;

      if (colIndex != null && !colIndex.isUnknown())

         newValue = (short) (index < 0 ? -1 : index);

      }

      {

      }

   }

    * @return  the column index.

    */

   @Override

   {

      if (!assertKnown(caption, dataType))

      {

      {

         if (pendingPushColumns)

         {

            pendingPushColumns = false;

        }

      }

   @Override

   public void setColumnCaption(final NumberType index, final character caption)

   {

      if (col == null)

      {

         LOG.warning("Invalid column index: " + index);

   public integer getColumnWidth(NumberType index)

   {

      flushWidgetAttrs();

      if (col != null)

      {

         return new integer(col.width);

         return;

      }

      if (col == null)

      {

         LOG.warning("Invalid column index: " + index);

   @Override

   public logical isShowHeader()

   {

   }

   /**

         return;

      }

   }

   /**

   @Override

   public character getThousandSeparator()

   {

   }

   /**

         return;

      }

   }

   /**

   @Override

   public character getDecimalSeparator()

   {

   }

   /**

         return;

      }

   }

   /**

   @Override

   public character getDateSeparator()

   {

   }

   /**

         return;

      }

   }

   /**

   @Override

   public character getShortDateFormat()

   {

   }

   /**

         return;

      }

   }

   /**

   public logical isColumnVisible(NumberType index)

   {

      flushWidgetAttrs();

      if (col != null)

      {

         return new logical(col.visible);

         return;

      }

      if (col == null)

      {

         return;

   @Override

   public void setCellIcon(NumberType nodeId, NumberType colIndex, NumberType imgId)

   {

   }

   /**

         return;

      }

      if(cellValue == null)

      {

   @Override

   public void setCellString(final NumberType nodeId, final NumberType colIndex, final character value)

   {

   }

   /**

   @Override

   public integer getCellFgColor(NumberType nodeId, NumberType colIndex)

   {

      return cellValue != null ? new integer(cellValue.getGuiRgb()) : new integer();

   }

   @Override

   public integer getCellBgColor(NumberType nodeId, NumberType colIndex)

   {

      return cellValue != null ? new integer(cellValue.getGuiRgb()) : new integer();

   }

    *          the owner's config was modified.

    */

   @Override

   {

      super.afterConfigUpdate(beforeUpdate);

       * to compare columns, since no proper equals() method is defined for columns. 

       */

      columns.clear();

   }

   /**

         return new integer();

      }

      final int imageIndex = cellImageList.size();

      newList.add(globalImageId);

      return new integer(imageIndex);

   }

   @Override

   public void setCellFgColor(final NumberType nodeId, final NumberType colIndex, final NumberType color)

   {

   }

   /**

   @Override

   public void setCellBgColor(final NumberType nodeId, final NumberType colIndex, final NumberType color)

   {

   }

   /**

      if (buildingTree <= 0)

      {

         pendingPushColumns = false;

      }

      else

    * @return  new node instance.

    */

   @Override

   {

      final int nodeId = getNextNodeId();

   }

   /**

      if (buildingTree <= 0)

      {

         pendingPushColumns = false;

      }

      else

    * @return  Reference to node entry object or {@code null} if not found.

    */

   @SuppressWarnings("unused")

   {

      {

         if (n.nodeId == nodeId.intValue())

         {

    */

   private final <T> void setCellValue(final NumberType nodeId,

                                       final NumberType colIndex,

                                       final T newValue)

   {

      if (!assertKnown(nodeId, colIndex))

         return;

      }

      if (n == null)

      {

         return;

    */

   private final <T> T getCellValue(final NumberType nodeId,

                                    final NumberType colIndex,

   {

      if (!assertKnown(nodeId, colIndex))

      {

         return null;

      }

      if (n == null)

      {

         return null;

      }

   }

   /**

 *        tree node face type

 */

@LegacyResource(resource = LegacyResource.TREE_NODE_COLLECTION)

extends WrappedResource,

        RemoveNode

{

   /**

 *        node type

 * @param <C> 

 *        config type

 *        resource type

*/

extends HandleResource

           DynamicResource

{

   /** Represents the default key and text values for a new created tree node. */

   private final static int CHILD_NODE_RELATIONSHIP    = 4;

   /** The nodes collection implementation. */

   /** The owning tree. */

   /** The owning tree node. */

   /**

    * Constructor.

    * @param   owner

    *          The owning node.

    */

   {

      super(tree._dynamic());

      this.tree = tree;

    * @return  an Iterator.

    */

   @Override

   {

      return nodes == null ? Collections.emptyListIterator() : nodes.listIterator();

   }

    *

    * @return  an Iterator.

    */

   {

                                                                             visibleOnly);

   }

   @Override

   public handle addNextNode(handle relativeNode, character key, character text)

   {

   }

   /**

   @Override

   public handle addChildNode(handle relativeNode, character key, character text)

   {

   }

   /**

         return;

      }

      _removeNode(node, null);

      tree.pushNodes();

   }

         return;

      }

      while (it.hasNext())

      {

         _removeNode(it.next(), it);

      int index = nodeIndex.intValue();

   // the internal root node has a zero index, indices of none root nodes are 1-based

      if (node == null)

      {

      int index = nodeIndex.intValue();

      // the internal root node has a zero index, indices of none root nodes are 1-based

      if (node == null)

      {

                     character key,

                     character text)

   {

      if (anchorIndex == null || anchorIndex.isUnknown())

      {

         relative = null;

            return new handle();

         }

      }

      Location location = Location.valueOf(relationType.intValue());

         return new handle();

      }

      if (treeNode != null)

      {

      super.delete();

      this.tree = null;

      if (nodes != null)

      {

         while (nodeIt.hasNext())

         {

            _removeNode(nodeIt.next(), nodeIt);

   @Override

   public integer getCount()

   {

      int collect = 0;

      while(iter.hasNext())

      {

         {

         }

         // don't take into account the internal root node

    * @param   it

    *          Optional iterator. When set, use it to remove the item from its list.

    */

   {

      if (node == null || nodes == null)

      {

         return;

      }

      // resource cleanup

   }

   /**

    *

    * @return  see above.

    */

   {

      return nodes == null ? -1 : nodes.indexOf(node);

   }

    * @throws  IndexOutOfBoundsException

    *          if the index is out of range (<tt>index &lt; 0 || index &gt;= size()</tt>)

    */

   {

      if (nodes == null)

      {

    *

    * @return  handle with wrapped {@link TreeNodeResource} instance, or unknown if the operation fails.

    */

                       Location location,

                       character key,

                       character text,

         text = key;

      }

      if (location == Location.CHILD)

      {

         nodes = new LinkedList<>();

      }

      switch (location)

      {

            }

            break;

         case CHILD:

            break;

      }

      tree.addNode(node, pushNodes);

      return new handle(node);

   }

    * @throws  RuntimeException

    *          when the supplied key is not unique

    */

   {

      if (key == null || text == null || parent == null)

      {

   /**

    * Recursive nodes iterator.

    */

   {

      /** Stack of iterators to handle recursion. */

      /** All or only expanded nodes to be iterated */

      private boolean visibleOnly;

       *

       * @param   node

       *          The parent node to iterate.

       * @param   visibleOnly

       *          All or only expanded nodes to be iterated.

       */

      {

         if (node != null && node.isNodeExpanded().booleanValue())

         {

            stack.push(nodes == null ? Collections.emptyListIterator() : nodes.listIterator());

         }

       * @param   visibleOnly

       *          All or only expanded nodes to be iterated.

       */

      {

         stack.push(nodes);

         this.visibleOnly = visibleOnly;

      @Override

      public boolean hasNext()

      {

         {

            if (it.hasNext())

            {

       * @throws NoSuchElementException if the iteration has no more elements

       */

      @Override

      {

         if (stack.isEmpty())

         {

            stack.pop();

         }

         if (it == null || !it.hasNext())

         {

            throw new NoSuchElementException();

         }

         if (!visibleOnly || node.isNodeExpanded().booleanValue())

         {

            if (coll != null)

            {

               if (coll.nodes != null && !coll.nodes.isEmpty())

               {

               }

            }

         }

      }

   }

import java.io.*;

import java.util.*;

/**

 * Treeview node configuration.

 */

public abstract class TreeNodeEntry

implements Externalizable

{

   private static final byte NULL = 0;

   private static final byte TEXT = 1;

   private static final byte NUMBER = 2;

    */

   public TreeNodeEntry()

   {

   }

   /**

    * @param   parentId

    *          Parent node id. Use unknown when the node has no parent.

    */

   {

      this.nodeId = nodeId;

      this.parentId = parentId;

    * @param   cellIndex

    *          Cell index.

    *

    * @return  cell value.

    *

    * @throws  IndexOutOfBoundsException

   }

   /**

    * @param out

    *        output stream

    * @param value

    *        value to be written

    * @throws IOException

    */

   {

      if (value == null)

      {

    * @throws IOException

    * @throws ClassNotFoundException 

    */

   {

      byte type = in.readByte();

      switch(type)

      /** */

      INACTIVE

   }

}

 * @param <N> 

 *        node type

 */

extends HandleResource

implements TreeNodeFace,

           DynamicResource

   protected String key;

   /** The owning tree view. */

   /** Node parent */

   /** Child nodes */

   /** Node tooltip */

   private String tooltip;

    * @param   parent

    *          Node parent.

    */

                           int nodeId,

                           String key,

   {

      super(tree._dynamic());

      this.nodeId = nodeId;

      this.key = key;

      this.parent = parent;

         return;

      }

      if (treeNode != null)

      {

         return new integer();

      }

      return i < 0 ? new integer() : new integer(i);

   }

   {

      LinkedList<String> stack = new LinkedList<>();

      while (current != null)

      {

         stack.add(label);

      }

      StringBuilder pathCollector = new StringBuilder();

   @Override

   public handle getPreviousNode()

   {

      int index = siblings._indexOf(this);

      if (index > 0)

   @Override

   public handle getNextNode()

   {

      if (index >= 0 && index < limit)

      {

   @Override

   public handle getFirstSiblingNode()

   {

      if (siblings != null)

      {

   @Override

   public handle getLastSiblingNode()

   {

      if (siblings != null)

      {

      super.delete();

      this.tree = null;

      if (nodeId == 0)

      }

      else

      {

      }

      tree.removeNode(this, true);

    *

    * @return  new instance of {@link TreeNodeEntry}.

    */

   /**

    * The method serializes the node state into the supplied entry instance.

    * @param   entry

    *          A valid {@link TreeNodeEntry} instance.

    */

   {

      expanded = entry.expanded;

    *

    * @return  see above.

    */

   {

      return _getNodes(true);

   }

    *

    * @return  see above.

    */

   {

      if (nodes == null && allocate)

      {

      }

   }

   /**

   int _getNodeLevel()

   {

      int level = -1;

      {

         level++;

      }

    *

    * @return  parent node.

    */

   {

      return parent;

   }

   {

      if (expanded)

      {

         {

         }

      }

extends WrappedResource,

        TreeFace

{

}

 * TreeView widget configuration.

 */

public class TreeViewConfig

{

   /**

    * Default constructor.

    * @return node entry instance

    */

   @Override

   {

      return TreeViewNodeEntry::new;

   }

public interface TreeViewNode

extends TreeNodeFace

{

}

extends TreeNodeEntry

{

   /** Node text. */

   /**