< prev index next >

modules/javafx.controls/src/main/java/javafx/scene/control/TreeTableRow.java

Print this page




 154                 if (oldValue != null) {
 155                     oldValue.expandedProperty().removeListener(weakTreeItemExpandedInvalidationListener);
 156                 }
 157 
 158                 oldValue = get();
 159 
 160                 if (oldValue != null) {
 161                     oldExpanded = oldValue.isExpanded();
 162                     oldValue.expandedProperty().addListener(weakTreeItemExpandedInvalidationListener);
 163                     // fake an invalidation to ensure updated pseudo-class state
 164                     weakTreeItemExpandedInvalidationListener.invalidated(oldValue.expandedProperty());
 165                 }
 166             }
 167     };
 168     private void setTreeItem(TreeItem<T> value) {
 169         treeItem.set(value);
 170     }
 171 
 172     /**
 173      * Returns the TreeItem currently set in this TreeCell.

 174      */
 175     public final TreeItem<T> getTreeItem() { return treeItem.get(); }
 176 
 177     /**
 178      * Each TreeTableCell represents at most a single {@link TreeItem}, which is
 179      * represented by this property.

 180      */
 181     public final ReadOnlyObjectProperty<TreeItem<T>> treeItemProperty() { return treeItem.getReadOnlyProperty(); }
 182 
 183 
 184 
 185     // --- Disclosure Node
 186     private ObjectProperty<Node> disclosureNode = new SimpleObjectProperty<Node>(this, "disclosureNode");
 187 
 188     /**
 189      * The node to use as the "disclosure" triangle, or toggle, used for
 190      * expanding and collapsing items. This is only used in the case of
 191      * an item in the tree which contains child items. If not specified, the
 192      * TreeTableCell's Skin implementation is responsible for providing a default
 193      * disclosure node.

 194      */
 195     public final void setDisclosureNode(Node value) { disclosureNodeProperty().set(value); }
 196 
 197     /**
 198      * Returns the current disclosure node set in this TreeTableCell.

 199      */
 200     public final Node getDisclosureNode() { return disclosureNode.get(); }
 201 
 202     /**
 203      * The disclosure node is commonly seen represented as a triangle that rotates
 204      * on screen to indicate whether or not the TreeItem that it is placed
 205      * beside is expanded or collapsed.

 206      */
 207     public final ObjectProperty<Node> disclosureNodeProperty() { return disclosureNode; }
 208 
 209 
 210     // --- TreeView
 211     private ReadOnlyObjectWrapper<TreeTableView<T>> treeTableView = new ReadOnlyObjectWrapper<TreeTableView<T>>(this, "treeTableView") {
 212         private WeakReference<TreeTableView<T>> weakTreeTableViewRef;
 213         @Override protected void invalidated() {
 214             TreeTableViewSelectionModel<T> sm;
 215             TreeTableViewFocusModel<T> fm;
 216 
 217             if (weakTreeTableViewRef != null) {
 218                 TreeTableView<T> oldTreeTableView = weakTreeTableViewRef.get();
 219                 if (oldTreeTableView != null) {
 220                     // remove old listeners
 221                     sm = oldTreeTableView.getSelectionModel();
 222                     if (sm != null) {
 223                         sm.getSelectedIndices().removeListener(weakSelectedListener);
 224                     }
 225 


 245                 fm = get().getFocusModel();
 246                 if (fm != null) {
 247                     // similar to above, but this time for focus
 248                     fm.focusedIndexProperty().addListener(weakFocusedListener);
 249                 }
 250 
 251                 get().editingCellProperty().addListener(weakEditingListener);
 252 
 253                 weakTreeTableViewRef = new WeakReference<TreeTableView<T>>(get());
 254             }
 255 
 256             updateItem();
 257             requestLayout();
 258         }
 259     };
 260 
 261     private void setTreeTableView(TreeTableView<T> value) { treeTableView.set(value); }
 262 
 263     /**
 264      * Returns the TreeTableView associated with this TreeTableCell.

 265      */
 266     public final TreeTableView<T> getTreeTableView() { return treeTableView.get(); }
 267 
 268     /**
 269      * A TreeTableCell is explicitly linked to a single {@link TreeTableView} instance,
 270      * which is represented by this property.

 271      */
 272     public final ReadOnlyObjectProperty<TreeTableView<T>> treeTableViewProperty() { return treeTableView.getReadOnlyProperty(); }
 273 
 274 
 275 
 276 
 277     /***************************************************************************
 278      *                                                                         *
 279      * Public API                                                              *
 280      *                                                                         *
 281      *************************************************************************
 282      * @param oldIndex
 283      * @param newIndex*/
 284 
 285 
 286     @Override void indexChanged(int oldIndex, int newIndex) {
 287         index = getIndex();
 288 
 289         // when the cell index changes, this may result in the cell
 290         // changing state to be selected and/or focused.


 459         if (! isEditing() && getTreeItem().equals(editItem)) {
 460             startEdit();
 461         } else if (isEditing() && ! getTreeItem().equals(editItem)) {
 462             cancelEdit();
 463         }
 464     }
 465 
 466 
 467 
 468     /***************************************************************************
 469      *                                                                         *
 470      * Expert API                                                              *
 471      *                                                                         *
 472      **************************************************************************/
 473 
 474     /**
 475      * Updates the TreeTableView associated with this TreeTableCell.
 476      *
 477      * @param treeTable The new TreeTableView that should be associated with this
 478      *         TreeTableCell.
 479      * @expert This function is intended to be used by experts, primarily
 480      *         by those implementing new Skins. It is not common
 481      *         for developers or designers to access this function directly.
 482      */
 483     public final void updateTreeTableView(TreeTableView<T> treeTable) {
 484         setTreeTableView(treeTable);
 485     }
 486 
 487     /**
 488      * Updates the TreeItem associated with this TreeTableCell.
 489      *
 490      * @param treeItem The new TreeItem that should be associated with this
 491      *      TreeTableCell.
 492      * @expert This function is intended to be used by experts, primarily
 493      *      by those implementing new Skins. It is not common
 494      *      for developers or designers to access this function directly.
 495      */
 496     public final void updateTreeItem(TreeItem<T> treeItem) {
 497         TreeItem<T> _treeItem = getTreeItem();
 498         if (_treeItem != null) {
 499             _treeItem.leafProperty().removeListener(weakLeafListener);
 500         }
 501         setTreeItem(treeItem);
 502         if (treeItem != null) {
 503             treeItem.leafProperty().addListener(weakLeafListener);
 504         }
 505     }
 506 
 507 
 508 
 509     /***************************************************************************
 510      *                                                                         *
 511      * Stylesheet Handling                                                     *
 512      *                                                                         *




 154                 if (oldValue != null) {
 155                     oldValue.expandedProperty().removeListener(weakTreeItemExpandedInvalidationListener);
 156                 }
 157 
 158                 oldValue = get();
 159 
 160                 if (oldValue != null) {
 161                     oldExpanded = oldValue.isExpanded();
 162                     oldValue.expandedProperty().addListener(weakTreeItemExpandedInvalidationListener);
 163                     // fake an invalidation to ensure updated pseudo-class state
 164                     weakTreeItemExpandedInvalidationListener.invalidated(oldValue.expandedProperty());
 165                 }
 166             }
 167     };
 168     private void setTreeItem(TreeItem<T> value) {
 169         treeItem.set(value);
 170     }
 171 
 172     /**
 173      * Returns the TreeItem currently set in this TreeCell.
 174      * @return the TreeItem currently set in this TreeCell
 175      */
 176     public final TreeItem<T> getTreeItem() { return treeItem.get(); }
 177 
 178     /**
 179      * Each TreeTableCell represents at most a single {@link TreeItem}, which is
 180      * represented by this property.
 181      * @return the tree item property
 182      */
 183     public final ReadOnlyObjectProperty<TreeItem<T>> treeItemProperty() { return treeItem.getReadOnlyProperty(); }
 184 
 185 
 186 
 187     // --- Disclosure Node
 188     private ObjectProperty<Node> disclosureNode = new SimpleObjectProperty<Node>(this, "disclosureNode");
 189 
 190     /**
 191      * The node to use as the "disclosure" triangle, or toggle, used for
 192      * expanding and collapsing items. This is only used in the case of
 193      * an item in the tree which contains child items. If not specified, the
 194      * TreeTableCell's Skin implementation is responsible for providing a default
 195      * disclosure node.
 196      * @param value the disclosure node
 197      */
 198     public final void setDisclosureNode(Node value) { disclosureNodeProperty().set(value); }
 199 
 200     /**
 201      * Returns the current disclosure node set in this TreeTableCell.
 202      * @return the disclosure node
 203      */
 204     public final Node getDisclosureNode() { return disclosureNode.get(); }
 205 
 206     /**
 207      * The disclosure node is commonly seen represented as a triangle that rotates
 208      * on screen to indicate whether or not the TreeItem that it is placed
 209      * beside is expanded or collapsed.
 210      * @return the disclosure node property
 211      */
 212     public final ObjectProperty<Node> disclosureNodeProperty() { return disclosureNode; }
 213 
 214 
 215     // --- TreeView
 216     private ReadOnlyObjectWrapper<TreeTableView<T>> treeTableView = new ReadOnlyObjectWrapper<TreeTableView<T>>(this, "treeTableView") {
 217         private WeakReference<TreeTableView<T>> weakTreeTableViewRef;
 218         @Override protected void invalidated() {
 219             TreeTableViewSelectionModel<T> sm;
 220             TreeTableViewFocusModel<T> fm;
 221 
 222             if (weakTreeTableViewRef != null) {
 223                 TreeTableView<T> oldTreeTableView = weakTreeTableViewRef.get();
 224                 if (oldTreeTableView != null) {
 225                     // remove old listeners
 226                     sm = oldTreeTableView.getSelectionModel();
 227                     if (sm != null) {
 228                         sm.getSelectedIndices().removeListener(weakSelectedListener);
 229                     }
 230 


 250                 fm = get().getFocusModel();
 251                 if (fm != null) {
 252                     // similar to above, but this time for focus
 253                     fm.focusedIndexProperty().addListener(weakFocusedListener);
 254                 }
 255 
 256                 get().editingCellProperty().addListener(weakEditingListener);
 257 
 258                 weakTreeTableViewRef = new WeakReference<TreeTableView<T>>(get());
 259             }
 260 
 261             updateItem();
 262             requestLayout();
 263         }
 264     };
 265 
 266     private void setTreeTableView(TreeTableView<T> value) { treeTableView.set(value); }
 267 
 268     /**
 269      * Returns the TreeTableView associated with this TreeTableCell.
 270      * @return the tree table view
 271      */
 272     public final TreeTableView<T> getTreeTableView() { return treeTableView.get(); }
 273 
 274     /**
 275      * A TreeTableCell is explicitly linked to a single {@link TreeTableView} instance,
 276      * which is represented by this property.
 277      * @return the tree table view property
 278      */
 279     public final ReadOnlyObjectProperty<TreeTableView<T>> treeTableViewProperty() { return treeTableView.getReadOnlyProperty(); }
 280 
 281 
 282 
 283 
 284     /***************************************************************************
 285      *                                                                         *
 286      * Public API                                                              *
 287      *                                                                         *
 288      *************************************************************************
 289      * @param oldIndex
 290      * @param newIndex*/
 291 
 292 
 293     @Override void indexChanged(int oldIndex, int newIndex) {
 294         index = getIndex();
 295 
 296         // when the cell index changes, this may result in the cell
 297         // changing state to be selected and/or focused.


 466         if (! isEditing() && getTreeItem().equals(editItem)) {
 467             startEdit();
 468         } else if (isEditing() && ! getTreeItem().equals(editItem)) {
 469             cancelEdit();
 470         }
 471     }
 472 
 473 
 474 
 475     /***************************************************************************
 476      *                                                                         *
 477      * Expert API                                                              *
 478      *                                                                         *
 479      **************************************************************************/
 480 
 481     /**
 482      * Updates the TreeTableView associated with this TreeTableCell.
 483      *
 484      * @param treeTable The new TreeTableView that should be associated with this
 485      *         TreeTableCell.
 486      * Note: This function is intended to be used by experts, primarily
 487      *         by those implementing new Skins. It is not common
 488      *         for developers or designers to access this function directly.
 489      */
 490     public final void updateTreeTableView(TreeTableView<T> treeTable) {
 491         setTreeTableView(treeTable);
 492     }
 493 
 494     /**
 495      * Updates the TreeItem associated with this TreeTableCell.
 496      *
 497      * @param treeItem The new TreeItem that should be associated with this
 498      *      TreeTableCell.
 499      * Note: This function is intended to be used by experts, primarily
 500      *       by those implementing new Skins. It is not common
 501      *       for developers or designers to access this function directly.
 502      */
 503     public final void updateTreeItem(TreeItem<T> treeItem) {
 504         TreeItem<T> _treeItem = getTreeItem();
 505         if (_treeItem != null) {
 506             _treeItem.leafProperty().removeListener(weakLeafListener);
 507         }
 508         setTreeItem(treeItem);
 509         if (treeItem != null) {
 510             treeItem.leafProperty().addListener(weakLeafListener);
 511         }
 512     }
 513 
 514 
 515 
 516     /***************************************************************************
 517      *                                                                         *
 518      * Stylesheet Handling                                                     *
 519      *                                                                         *


< prev index next >